Question

C++ please, thank you!

Design a class named ArrayClass that has an array of floating-point numbers. The constructor should accept an integer argument and allocate the array on the heap to hold that many numbers. The default constructor should allocate an array that can hold one number.

When the user attempts to store items, you must make a copy constructor that correctly produces a new copy of an ArrayClass object from an old one.

If the user attempts to store more numbers than the array can currently hold, you should reallocate into a new array that is twice the old array's size.

The destructor should free the memory held by the array. In addition, there should be member functions to perform the following operations, declared in the following way:

• Store a number at the end of the array
  void store(float value)
  
• Retrieve a number from any element of the array
  float fetch(int index)
  
• Return the highest value stored in the array
  float maxValue()
  
• Return the lowest value stored in the array
  float minValue()
  
• Return the average of all the numbers stored in the array
  float averageValue()
  

Demonstrate your class in a program. Your program must not leak memory -- failing to delete allocated memory will be considered a major error. Your program must also never access memory that is not currently allocated.

Answer 1

Thanks for the question. Below is the code you will be needing. Let me know if you have any doubts or if you need anything to change.

If you are satisfied with the solution, please rate the answer.

Thank You !
===========================================================================

#include<iostream>
using namespace std;
class ArrayClass{
   private:
       float *p;
       int size;
       int numCount;
   public:
       ArrayClass(int =1);
       ~ArrayClass();
       ArrayClass(const ArrayClass&);
       void store(float);
       float fetch(int);
       float maxValue();
       float minValue();
       float averageValue();
};

       ArrayClass::ArrayClass(int size):size(size){
           p = new float[size];
       }
       ArrayClass::~ArrayClass(){
           delete [] p;
       }
       ArrayClass::ArrayClass(const ArrayClass& a){

           int size = a.size;
           p = new float[size];
           for(int i=0; i<a.numCount;i++){
               *(p+i) = *(a.p+i);
           }
           numCount=a.numCount;
       }
       void ArrayClass::store(float val){
           if(numCount<size) {
               *(p+numCount)=val;
               numCount++;
           }
       }
       float ArrayClass::fetch(int index){
           if(0<=index && index<numCount) return *p+numCount;
           else return 0;
       }
       float ArrayClass::maxValue(){
           int maxIndex = 0;
           for(int i=0; i<numCount;i++){
               if(*(p+i)>*(p+maxIndex)) maxIndex =i;
           }
           return *(p+maxIndex);
       }
       float ArrayClass::minValue(){
           int minIndex = 0;
           for(int i=0; i<numCount;i++){
               if(*(p+i)<*(p+minIndex)) minIndex =i;
           }
           return *(p+minIndex);
       }
       float ArrayClass::averageValue(){
           float total=0;
           for(int i=0; i<numCount;i++) total+= *(p+i);
           return total/numCount;
       }
      
      
      
      
       int main(){
          
           ArrayClass arr(10);
           for(int i=1;i<=10;i++) arr.store(i);
          
           cout<<"Max Value: "<<arr.maxValue()<<endl;
           cout<<"Min Value: "<<arr.minValue()<<endl;
           cout<<"Avg Value: "<<arr.averageValue()<<endl;
          
           ArrayClass dup = arr;
          
           cout<<"Max Value in duplicate: "<<dup.maxValue()<<endl;
           cout<<"Min Value in duplicate: "<<dup.minValue()<<endl;
           cout<<"Avg Value in duplicate: "<<dup.averageValue()<<endl;
          
       }

==================================================================