Question

you will write a templated array class. Called MyArray with member variables ptr and array_size. This array must use dynamic memory--see program shell, names should remain unchanged.

The following is a list of required member functions of the array class along with a rubric:

(1pts) program compiles

(2pts) default constructor

(2pts) parametered constructor which feeds MyArray a size.

(10pts) copy constructor

    8pts for performing a *deep* copy

    2pts for correct syntax

(10pts) overloaded = operator

     7pts for functioning properly

     3pts for being capable of performing a chained assignment

(10pts) overloaded [] operator--a mostly normal [] operator, but one that performs bounds checking****.

     5pts for performing bounds checking (graded by hand)

     5pts for functioning properly

(5pts) Write a child class for the above templated class called SmallArray--Your child class doesn't have to do anything, just write a default and parametered constructor. Write the parametered constructor in such a way that it passes its arguments to the parent.

     1pts default constructor

     2pts parametered constructor

     2pts proper inheritance syntax

#ifndef MY_ARRAY_H
#define MY_ARRAY_H

template <class T>
class MyArray{
private:
T* ptr;
int array_size;
  
public:
  

T& operator[](int index) const;//do not modify
MyArray<T> operator=(MyArray<T>);//do not modify

int size(){
return array_size;
}
  
//These exist for my unit tests, do not use them in any of your member functions
//but feel free to use them to test your code.
T getElement(int index) const{
return ptr[index];
}

void setElement(T value, int index){
ptr[index] = value;
}
  
};

//test function, do not modify
template <typename T>
MyArray<T> copy_test_2(MyArray<T> temp_val){
MyArray<T> temp(temp_val);
return temp;
}

#endif

No changes in main.ccp

Answer 1

screenshot

--------------------------------------

Program

MyArray.h

#ifndef MY_ARRAY_H
#define MY_ARRAY_H
//Template
template <class T>
class MyArray {
//Instance variables
private:
   T* ptr;
   int array_size;
//Member functions
public:
   //Default constructor
   MyArray<T>() {
       array_size = 0;
       ptr = new T[array_size];
   }
   //Parameterized constructor
   MyArray<T>(int sz) {
       array_size = sz;
       ptr = new T[array_size];
   }
   //Copy constructor
   MyArray<T>(const MyArray<T>& myarray) {
       array_size = myarray.array_size;
       ptr = new int[array_size];
       for (int i = 0; i < array_size; i++) {
           ptr[i] = myarray.ptr[i];
       }
   }
   //Overload index operator
   T& operator[](int index) const;//do not modify
   //Overload equals operator
   MyArray<T> operator=(MyArray<T>);//do not modify
   //Get size of the array
   int size() {
       return array_size;
   }

   //These exist for my unit tests, do not use them in any of your member functions
   //but feel free to use them to test your code.
   T getElement(int index) const {
       return ptr[index];
   }

   void setElement(T value, int index) {
       ptr[index] = value;
   }

};

//test function, do not modify
template <typename T>
MyArray<T> copy_test_2(MyArray<T> temp_val) {
   MyArray<T> temp(temp_val);
   return temp;
}

#endif

MyArray.cpp

#include "MyArray.h"
#include<iostream>
using namespace std;
//Overload index operator
template <class T>
T& MyArray<T>::operator[](int index) const {
   if (index < 0 || index >= array_size) {
       cout << "\nError:Index " << index << " out of range" << endl;
       exit(1);
   }
   return ptr[index];
}
//Overload equals operator
template <class T>
MyArray<T> MyArray<T>::operator=(MyArray<T> myarray) {
   if (&myarray != this) {
       if (array_size != myarray.array_size) {
           delete[] ptr;
           array_size = myarray.array_size;
           ptr = new int[array_size];
       }
       for (int i = 0; i < array_size; i++) {
           ptr[i] =myarray.ptr[i];
       }
   }
   return *this;
}

SmallArray.h

#include "MyArray.h"
template <class T>
class SmallArray :public MyArray<T> {
   //default constructor
   SmallArray<T>() {

   }
   //Parameterized constructor
   SmallArray<T>(int sz) : MyArray(sz) {

   }
};

main.cpp

#include <iostream>
#include "MyArray.h"
using namespace std;
int main()
{
   //Create an object
   MyArray<int> myarray(3);
   //Display size
   cout << "Size of myarray: " << myarray.size() << endl;
   //Create a copy
   MyArray<int> myarray2=copy_test_2(myarray);
   //Display size
   cout << "Size of the copied array: "<<myarray2.size() << endl;
}

--------------------------------------

output

Size of myarray: 3
Size of the copied array: 3