Question

In C++ and comment so I UNDERSTAND

Implement a class named DynamicArray that has the following members:
A pointer to hold a dynamically allocated array, of type int.
A member variable to hold the size of the array.
A default constructor, which will allocate an array of size 10
A parameterized constructor, which takes a size and use the size to allocate array.
A copy constructor, which performs deep copy.
A copy assignment operator, which performs deep copy and supports self-assignment of the form x = x. See reference: https://stackoverflow.com/questions/4172722/what-is-the-rule-of-three
A destructor that recycles allocated memory
A member function that fills array with random numbers.
A member function that prints all elements from the array.
A member function that performs insertion sort.

Answer 1

//DynamicArray.h

class DynamicArray{
       private:
       int *data; // pointer variable
       int size; // member variable
   public:
       DynamicArray();
       DynamicArray(int size);
       DynamicArray(const DynamicArray &obj);
       DynamicArray& operator= (const DynamicArray &obj);
       ~DynamicArray(){ // Destructor
           delete [] data;
       }
       void insert();
       void print();
       void sort();
};

//DynamicArray.cpp

#include<iostream>
#include<cstdlib>
#include<time.h>
#include"DynamicArray.h"
using namespace std;

DynamicArray::DynamicArray(){ // default constructor
   size = 10;
   data = new int[size];
}
DynamicArray::DynamicArray(int size){ // parametrized constructor
   this->size = size;
   this->data = new int[this->size];
}
DynamicArray::DynamicArray(const DynamicArray &obj){ // copy constructor
   size = obj.size;
   data = new int[size];
   for(int i = 0 ; i < size; i++){
       data[i] = obj.data[i];
   }
}
DynamicArray& DynamicArray::operator= (const DynamicArray &obj){ // operator=
   if (this != &obj) {
data = new int[obj.size];
size = obj.size;
for (int i=0; i<size; i++) data[i] = obj.data[i];
}
return *this;
}

void DynamicArray::insert(){ // insert function
  
   for(int i = 0 ; i < this->size; i++){
       int d = rand()%100;
       this->data[i] = d;
   }
}
void DynamicArray::print(){ // print function
   for(int i = 0; i < this->size; i++){
       cout<<this->data[i]<<" ";
   }
   cout<<"\n";
}
void DynamicArray::sort(){ // insertionsort function
   int i,j,key;
   for(i = 1; i < size; i++){
       j = i-1;
       key = data[i];
       while(j >= 0 && data[j] > key){
           data[j+1] = data[j];
           j--;
       }
       data[j+1] = key;
   }
}
int main(){
   DynamicArray obj; // default
   srand(time(0)); // random number generation
   obj.insert();
   cout<<"Default Constructor: \n";
   cout<<"Before Sorting : "<<" ";
   obj.print();
   cout<<"After Sorting : "<<" ";
   obj.sort();
   obj.print();
   DynamicArray obj1(20);
   obj1.insert();
   cout<<"Parametrized Constructor: \n";
   cout<<"Before Sorting : "<<" ";
   obj1.print();
   cout<<"After Sorting : "<<" ";
   obj1.sort();
   obj1.print();
   cout<<"Copy Constructor: \n";
   DynamicArray obj3 = obj;
   obj3.print();
}

/* OUTPUT SCREEN */\

Default Constructor: Before Sorting : 84 56 2 40 62 71 87 80 57 25 After Sorting : 2 25 40 56 57 62 71 80 84 87 Parametrized Constructor: Before Sorting : 11 16 46 4 67 33 48_40 27 38 75 78 91 60 35 57 81 22 77 40 After Sorting: 4 11 16 22 27 33 35 38 40 40 46 48 57 60 67 75 77 78 81 91 Copy Constructor: 2 25 40 56 57 62 71 80 84 87