Question

Replace the fixed size array with a dynamic array

Add a constructor that passes the size of the array as a parameter

Add a function that copies a dynamic array parameter into this array.

Add a copy constructor to intArray

Add a function that displays the array to a arbitrary stream

Derive intSortedArray from intArray

Add functions that enter elements into the array in sorted order

Override any base class functions that insert elements out of order.

*Note: I NEED help to write out this problem in C++ while using Visual Studio 2017 and NEED a source.cpp/main.cpp

//code

// intArray.h

class intArray
{
public:
   //constructors
   intArray();
   //destructors
   ~intArray();

   //predicates
   bool isFull();
   bool isEmpty();

   //accessors
   int getPopulation();
   int getCapacity();

   //custom methods
   void fill(int value);
   int find(int value);
   bool insertAt(int new_item, int new_position);
   void show();
private:
   int population;
   int capacity;
   int elts[16];
};

// intArray.cpp

#include <iostream>
#include <string>
#include "intArray.h"
using namespace std;

intArray::intArray()
{
   population = 0;
   capacity = 16;
}
intArray::~intArray()
{
   population = 0;
}
void intArray::fill(int value)
{
   for (int i = 0; i < population; ++i)
       elts[i] = value;
}
int intArray::find(int value)
{
   int i = 0;
   for (i = 0; i < population && elts[i] != value; ++i)
       ;
   if (i == population) i = -1;
   return i;
}
int intArray::getCapacity()
{
   return capacity;
}
int intArray::getPopulation()
{
   return population;
}
bool intArray::insertAt(int new_elt, int new_position)
{
   if (capacity <= population)
       return false;
   if (new_position < 0 || population < new_position)
       return false;

   //move the elements from new position to population - 1 down one position
   for (int i = population - 1; i >= new_position; --i)
       elts[i + 1] = elts[i];
   elts[new_position] = new_elt;
   population++;
   return true;
}
bool intArray::isEmpty()
{
   return population <= 0;
}
bool intArray::isFull()
{
   return capacity <= population;
}
void intArray::show()
{
   for (int i = 0; i < population; ++i)
       cout << elts[i] << ' ';
}

//source.cpp

#include <iostream>
#include "intArray.h"
using namespace std;

int main()
{

     return 0;

}

Answer 1

Answer; //ran on dev platform

#include <iostream>
#include <string>
//#include "intArray.h"
using namespace std;

//main function
int main()
{
}

//CLASS CODE
class intArray
{
public:
//constructors
intArray();
intArray(int len);
//destructors
~intArray();

//dynamic array parameter
void addLen(int l);

//display function
void display();

//
void sortEntry(int mxIndex);
int* bs(int elt[], int l);

// ////predicates
bool isFull();
bool isEmpty();

//// //accessors
// int getPopulation();
// int getCapacity();
////
//// //custom methods
////

// void fill(int value);
// int find(int value);
// bool insertAt(int new_item, int new_position);
void show();

private:
int population;
int capacity;
// int elts[16];
int* elt;
int len;
int mxIndex;

};

intArray::intArray(int l)
{
len=l;
mxIndex=l;
elt = new int [l];

}

//dynamic array parameter
void intArray::addLen(int l){
len=l;
}
//Display function
void intArray::display(){
for (int i;i<len;i++){
cout<<elt[i];
}
}

//Function to Sort the intArray using bubbleSort
int* intArray::bs(int elt[], int l) {
bool ex;
do {
ex = false;
for (int i=0; i<l-1; i++) {
if (elt[i] > elt[i+1]) {
int temp = elt[i]; elt[i] = elt[i+1]; elt[i+1] = temp;
ex = true;
}
}
} while (ex);
return elt;
}

//Add functions that enter elements into the array in sorted order

void intArray::sortEntry(int mxIndex)
{
int i;
elt=bs(elt,i);
cout<<"Enter input = ";
cin>>i;
elt[mxIndex]=i;
elt=bs (elt,i);

}

intArray::intArray()
{
population = 0;
capacity = 16;
}

intArray::~intArray()
{
population = 0;
}

bool intArray::isEmpty()
{
return population <= 0;
}

bool intArray::isFull()
{
return capacity <= population;
}

void intArray::show()
{
for (int i = 0; i < population; ++i)
cout << elt[i] << ' ';
}