Question

Please do it carefully

Using the header file ( MyArray.h ) Type the implementation file MyArray.cpp, and a test file to test the functionality of the class.

Hint: read all the explanations in the header with attention.

MyArray.h :

#ifndef MYARRAY_H

#define MYARRAY_H

#include <iostream>

using namespace std;

class MyArray

{

friend ostream& operator<<( ostream & output, const MyArray & rhs); // to output the values of the array

friend istream& operator>>( istream & input, MyArray & rhs); // to input the values of the array

public:

//constructors

MyArray(); //empty constructor , SIZE <- 1, data <- {0}

MyArray(int n); //SIZE <- n, data <- {0, ..., 0}

MyArray(int n, double val); //SIZE <- n, data <- {val, ..., val}

MyArray(const MyArray& src); //copy constructor

MyArray(int n, double* arr ); //SIZE <- n, data <- {arr[0], ..., arr[n-1]}

//utility functions

void printArray() const;

void fill(double val);

int getArraySize() const;

double* getArray();

double* getArray() const;

//indexing

double& operator[](int ind); //subscript operator for non-const objects returns modifiable lvalue

double operator[](int ind) const; //subscript operator for non-const objects returns rvalue

//assignment

MyArray& operator=(const MyArray& rhs);

//comparison

bool operator!=(const MyArray& rhs) const; //equality operator 1

bool operator==(const MyArray& rhs) const; //equality operator 2

//math functions

MyArray& operator+=(const MyArray& rhs) ; // additive assignment

MyArray& operator-=(const MyArray& rhs) ; // subtractive assignment

MyArray& operator*=(const MyArray& rhs) ; // (element-wise) multiplicative assignment

MyArray& operator/=(const MyArray& rhs) ; // (element-wise) divisive assignment

MyArray& operator^(const int& pwr) ; // element-wise power

private:

double* array;

int SIZE;

};

#endif

/* you need Dynamic memory Allocation , and example is given for empty constructor

MyArray::MyArray()

:SIZE(1)

{

//cout<<" constructor MyArray::MyArray()"<<endl;

SIZE=1;

array = new double[1];

fill(0);

}

*/

Answer 1

//MyArray.h

#ifndef MYARRAY_H
#define MYARRAY_H
#include <iostream>

using namespace std;

class MyArray
{

   friend ostream& operator<<( ostream & output, const MyArray & rhs); // to output the values of the array
   friend istream& operator>>( istream & input, MyArray & rhs); // to input the values of the array
public:
   //constructors
   MyArray(); //empty constructor , SIZE <- 1, data <- {0}
   MyArray(int n); //SIZE <- n, data <- {0, ..., 0}
   MyArray(int n, double val); //SIZE <- n, data <- {val, ..., val}
   MyArray(const MyArray& src); //copy constructor
   MyArray(int n, double* arr ); //SIZE <- n, data <- {arr[0], ..., arr[n-1]}
  
   //utility functions
   void printArray() const;
   void fill(double val);
   int getArraySize() const;
   double* getArray();
   double* getArray() const;

   //indexing
   double& operator[](int ind); //subscript operator for non-const objects returns modifiable lvalue
   double operator[](int ind) const; //subscript operator for non-const objects returns rvalue

   //assignment
   MyArray& operator=(const MyArray& rhs);

   //comparison
   bool operator!=(const MyArray& rhs) const; //equality operator 1
   bool operator==(const MyArray& rhs) const; //equality operator 2
  
   //math functions
   MyArray& operator+=(const MyArray& rhs) ; // additive assignment
   MyArray& operator-=(const MyArray& rhs) ; // subtractive assignment
   MyArray& operator*=(const MyArray& rhs) ; // (element-wise) multiplicative assignment
   MyArray& operator/=(const MyArray& rhs) ; // (element-wise) divisive assignment
  
   MyArray& operator^(const int& pwr) ; // element-wise power
  
private:
   double* array;
   int SIZE;
};
#endif

//MyArray.cpp

#include "MyArray.h"
#include<math.h>
MyArray::MyArray(){
   SIZE = 1;
   array = new double[SIZE];
   for(int i=0;i<SIZE;i++)array[i] = 0;
}
MyArray::MyArray(int n){
   SIZE = n;
   array = new double[SIZE];
   for(int i=0;i<SIZE;i++)array[i] = 0;
}
MyArray::MyArray(int n, double val){
   SIZE = n;
   array = new double[SIZE];
   for(int i=0;i<SIZE;i++)array[i] = val;
}
MyArray::MyArray(const MyArray& src){
   SIZE = src.SIZE;
   array = new double[SIZE];
   for(int i=0;i<SIZE;i++)array[i] = src.array[i];
}
MyArray::MyArray(int n, double* arr ){
   SIZE = n;
   array = new double[SIZE];
   for(int i=0;i<SIZE;i++)array[i] = arr[i];
}
  
   //utility functions
void MyArray::printArray() const{
   for(int i=0;i<SIZE;i++){
       cout<<array[i]<<" ";
   }
}
void MyArray::fill(double val){
   for(int i=0;i<SIZE;i++)array[i] = val;
}
int MyArray::getArraySize() const{
   return SIZE;
}
double* MyArray::getArray(){
   return array;
}
double* MyArray::getArray() const{
   return array;
}

   //indexing
double& MyArray::operator[](int ind){
   return array[ind];
}
double MyArray::operator[](int ind) const{
   return array[ind];
}

   //assignment
MyArray& MyArray::operator=(const MyArray& rhs){
  
   return *(new MyArray(rhs));
}

   //comparison
bool MyArray::operator!=(const MyArray& rhs) const{
   if(SIZE != rhs.SIZE)return true;
   for(int i=0;i<SIZE;i++){
       if(array[i] != rhs.array[i])return true;
   }
   return false;
}
bool MyArray::operator==(const MyArray& rhs) const{
   if(SIZE != rhs.SIZE)return false;
   for(int i=0;i<SIZE;i++){
       if(array[i] != rhs.array[i])return false;
   }
   return true;
}
  
   //math functions
MyArray& MyArray::operator+=(const MyArray& rhs) {
   for(int i=0;i<SIZE && i<rhs.SIZE ;i++){
       array[i]+=rhs.array[i];
   }
   return *this;
}
MyArray& MyArray::operator-=(const MyArray& rhs) {
   for(int i=0;i<SIZE && i<rhs.SIZE ;i++){
       array[i]-=rhs.array[i];
   }
   return *this;
}
MyArray& MyArray::operator*=(const MyArray& rhs) {
   for(int i=0;i<SIZE && i<rhs.SIZE ;i++){
       array[i]*=rhs.array[i];
   }
   return *this;
}
MyArray& MyArray::operator/=(const MyArray& rhs){
   for(int i=0;i<SIZE && i<rhs.SIZE ;i++){
       array[i]/=rhs.array[i];
   }
   return *this;
}
  
MyArray& MyArray::operator^(const int& pwr) {
   for(int i=0;i<SIZE ;i++){
       array[i] =   pow(array[i] , pwr);
   }
   return *this;
}
ostream& operator<<( ostream & output, const MyArray & rhs){
   for(int i=0;i<rhs.SIZE;i++)
       output<<rhs.array[i]<<" ";
   return output;
}
istream& operator>>( istream & input, MyArray & rhs){
   for(int i=0;i<rhs.SIZE;i++)
       input>>rhs.array[i];
   return input;
}

//main.cpp

#include"MyArray.cpp"

int main(){
   double arr1[] = {1,2,3,4};
   MyArray myarr1(4,arr1);
   MyArray myarr2(8,2.5);
  
   cout<<myarr1<<endl;
   cout<<myarr2<<endl;
   MyArray myarr3(myarr1);
   cout<<myarr3<<endl;
  
   MyArray myarr4 = myarr3;
   cout<<myarr4<<endl;
}