Question

1. Variable Size Array with Classes, Testing.

   Study Code and Object Definition Windows of Microsoft Visual Studio described here. As you work on the below project, demonstrate to the instructor the usage of this feature.

   Create a project titled Lab11_VarArrayTest. Implement the dynamically expanding and contracting array of doubles described in the previous lab as a class. You should use this class definition. The class attributes are a pointer to the dynamically allocated array dAarray and the array size size This class contains two groups of methods:

   • Member functions output(), check() addNumber() and removeNumber() have exactly the same functionality as described in the previous lab.
   • copy constructor, overloaded assignment and destructor ensure correct handling of the objects with dynamically allocated members.

   Your code should work with this test program. It is designed to test your implementation of varArray class.

   You are free to modify the class and the test program but you cannot change the principle of dynamic allocation of the array (i.e. you cannot make the member variables automatic) or remove testing of all the methods from the test program.

2. Variable Size Array with Classes, Implementation. Create a project titled Lab11_VarArrayClasses. Using the class implemented in the first part of this lab, implement the functionality of the second part of the previous lab. That is, write a program that asks the user to input numbers to add to and remove from the array and then prints its contents.
   
   Test File

   
   
   #include <iostream>
   #include "vararray.h"
   
   using std::cout; using std::endl;
   
   
   void testfunc(varArray); // function to test pass-by-value for varArray
   
   int main(){
   
      varArray a1;
   
      // testing regular member functions
      a1.addNumber(1.);
      a1.addNumber(2.);
      a1.addNumber(3.);
      a1.addNumber(3.); // trying to add duplicate, should not add it
      
      cout << "a1 size is after number addition is: " << a1.arraySize() << endl;
   
      if(a1.check(1.) != -1) // check() returns -1 if number not present
         cout << "1 is present in the array" << endl;
   
      if(a1.check(5.) != -1)
         cout << "5 is present in the array" << endl;
   
      cout << "a1 before removal of 2.0: "; a1.output();
      a1.removeNumber(2.);
      cout << "a1 after removal of 2.0: "; a1.output();
   
      // uncomment this when you debugged the first part
      /*
      testfunc(a1); // testing copy constructor
      
      cout << "a1 after testfunc call: ";
      a1.output(); // if destructor is implemented correctly
                   // this should print properly after testfunc completes
   
      varArray a2, a3;
   
      a3=a2=a1; // testing stackability of the overloaded assignment
      cout << "a3 after stackable assingment: ";
      a3.output();
   
      a3=a3; // testing protection against self-assingment
      cout << "a3 after self-assignment: ";
      a3.output();
      */
   }
   
   
   /*
   // tests pass-by-value for object of class varArray
   void testfunc(varArray va){ // copy constructor is invoked on "va"
       cout << "parameter va: "; 
       va.output(); 
   } // destructor is invoked when "va" goes out of scope
   */
   
   Header
   
   
   
   

   #ifndef VARARRAY_H_
   #define VARARRAY_H_
   
   class varArray{
   public:
     varArray(); // void constructor
     int arraySize() const {return size;} // returns the size of the array
   
     int check(double number); // returns index of element containg "number" or -1 if none
     void addNumber(double);    // adds number to the array
     void removeNumber(double); // deletes the number from the array
     void output();      // prints the values of the array
   
     // big three
     varArray(const varArray&); // copy constructor
     varArray& operator=(const varArray&); // overloaded assignment
     ~varArray(); // destructor
   
   private:
     double *dArray; // pointer to the dynamically allocated array
     int size;   // array size
   };
   
   #endif /* VARARRAY_H_ */
   
   Definitions (another .cpp file) from last lab
   
   
   

   // prints the values in "arrayPtr" of "size"
   void output(double *arrayPtr, int size)
   {
           cout << "\n Your numbers: ";
           // Loops till end of the array and displays each element
           for (int c = 0; c < size; c++)
                   cout << arrayPtr[c] << " ";
   }// End of function output
   
    // returns the index of the element in "arrayPtr" of "size"
    // that corresponds to the element holding "number"
    // if number is not in the array, returns -1
   int check(double *arrayPtr, double number, int size)
   {
           // Initially found index is -1 for not found
           int index = -1;
   
           // Loops until end of the array
           for (int c = 0; c < size; c++)
           {
                   // Checks if current index position value of the array
                   // is equals to the parameter number then return
                   // c value as found index position
                   if (arrayPtr[c] == number)
                           return c;
           }// End of for loop
            // End of the loop returns -1 for not found
           return index;
   }// End of function check
   
    // adds "number" to the array pointed to by "arrayPtr" of "size".
    // if the number is not already there, if "number" is there - no action
    // Note, the size of the array is thus increased.
   void addNumber(double *& arrayPtr, double number, int &size)
   {
           // Calls the function to check whether the number is available
           // in the array or not
           // Stores the return found status
           int found = check(arrayPtr, number, size);
   
           // Checks if the found status is -1 then number not found
           if (found == -1)
           {
                   // Creates a temporary array with existing size plus one
                   double *temp = new double[size + 1];
   
                   // Loops till end of the array and assign
                   // each element of the existing array to temp
                   for (int c = 0; c < size; c++)
                           temp[c] = arrayPtr[c];
   
                   // Increase the size by one
                   size++;
   
                   delete[] arrayPtr; // deallocating the array
   
                   // Resize the existing array with new size
                   arrayPtr = new double[size];
   
                   // Loops till end of the array minus one term
                   // and assign each element of the temp to existing array
                   arrayPtr = temp;
   
                   // Assigns the parameter number to existing array last position
                   arrayPtr[size - 1] = number;
           }// End of if condition
   
            // Otherwise number found
           else
                   cout << "\n The number found at: " << found << "\n Cannot add duplicate number.";
   }// End of function addNumber
   
    // removes a "number" from the "arrayPtr" of "size".
    // if "number" is not there -- no action
    // note, "size" changes
   void removeNumber(double *& arrayPtr, double number, int &size)
   {
           // Calls the function to check whether the number is available
           // in the array or not
           // Stores the return found status
           int found = check(arrayPtr, number, size);
   
           // Checks if the found status is not -1 then number found
           if (found != -1)
           {
                   // Creates a temporary array with existing size plus one
                   double *temp = new double[size];
   
                   // Shift each element to left from found index position to end of the array
   
                   // Loops from found index position to end of the array
                   // and assign each next index position element to current index position
                   for (int c = found; c < size; c++)
                           arrayPtr[c] = arrayPtr[c + 1];
   
                   // Loops till end of the existing array
                   // Assign each element of the existing array to temp array
                   for (int c = 0; c < size; c++)
                           temp[c] = arrayPtr[c];
   
                   // Decrease the size by one
                   size--;
   
                   delete[] arrayPtr; // deallocating the array
   
                   // Resize the existing array with new size
                   arrayPtr = new double[size];
   
                   // Loops till end of the array minus one term
                   // and assign each element of the temp array to existing array
                   for (int c = 0; c < size; c++)
                           arrayPtr[c] = temp[c];
           }// End of if condition
   
            // Otherwise number not found
           else
                   cout << "\n The number " << number << " not found.";
   }// End of function removeNumber

Answer 1

// varArray.h

#ifndef VARARRAY_H_

#define VARARRAY_H_

#include <iostream>

using namespace std;

class varArray{

public:

varArray(); // void constructor

int arraySize() const {return size;} // returns the size of the array

int check(double number); // returns index of element containg "number" or -1 if none

void addNumber(double);    // adds number to the array

void removeNumber(double); // deletes the number from the array

void output();      // prints the values of the array

// big three

varArray(const varArray&); // copy constructor

varArray& operator=(const varArray&); // overloaded assignment

~varArray(); // destructor

private:

double *dArray; // pointer to the dynamically allocated array

int size;   // array size

};

#endif /* VARARRAY_H_ */

//end of varArray.h

// varArray.cpp

#include "varArray.h"

varArray::varArray()

{

       dArray = NULL;

       size = 0;

}

varArray::varArray(const varArray &other)

{

       size = other.size;

       dArray = new double[size];

       for(int i=0;i<size;i++)

             dArray[i] = other.dArray[i];

}

varArray& varArray::operator=(const varArray& other)

{

       if(this != &other)

       {

             if(dArray != NULL)

                    delete [] dArray;

             size = other.size;

             dArray = new double[size];

             for(int i=0;i<size;i++)

                    dArray[i] = other.dArray[i];

       }

       return *this;

}

varArray::~varArray()

{

       if(dArray != NULL)

             delete[] dArray;

}

// prints the values in "arrayPtr" of "size"

void varArray::output()

{

        cout << "\n Your numbers: ";

        // Loops till end of the array and displays each element

        for (int c = 0; c < size; c++)

                cout << dArray[c] << " ";

}// End of function output

// returns the index of the element in "arrayPtr" of "size"

// that corresponds to the element holding "number"

// if number is not in the array, returns -1

int varArray::check(double number)

{

        // Initially found index is -1 for not found

        int index = -1;

        // Loops until end of the array

        for (int c = 0; c < size; c++)

        {

                // Checks if current index position value of the array

                // is equals to the parameter number then return

                // c value as found index position

                if (dArray[c] == number)

                        return c;

        }// End of for loop

         // End of the loop returns -1 for not found

        return index;

}// End of function check

// adds "number" to the array pointed to by "arrayPtr" of "size".

// if the number is not already there, if "number" is there - no action

// Note, the size of the array is thus increased.

void varArray::addNumber(double number)

{

       // Calls the function to check whether the number is available

       // in the array or not

       // Stores the return found status

       int found = check(number);

       // Checks if the found status is -1 then number not found

       if (found == -1)

       {

               // Creates a temporary array with existing size plus one

               double *temp = new double[size + 1];

               // Loops till end of the array and assign

               // each element of the existing array to temp

               for (int c = 0; c < size; c++)

                       temp[c] = dArray[c];

               // Increase the size by one

               size++;

               delete[] dArray; // deallocating the array

               // Resize the existing array with new size

               dArray = new double[size];

               // Loops till end of the array minus one term

               // and assign each element of the temp to existing array

               dArray = temp;

               // Assigns the parameter number to existing array last position

               dArray[size - 1] = number;

       }// End of if condition

        // Otherwise number found

       else

             cout << "\n The number found at: " << found << "\n Cannot add duplicate number.";

}// End of function addNumber

// removes a "number" from the "arrayPtr" of "size".

// if "number" is not there -- no action

// note, "size" changes

void varArray::removeNumber(double number)

{

        // Calls the function to check whether the number is available

        // in the array or not

        // Stores the return found status

        int found = check(number);

        // Checks if the found status is not -1 then number found

        if (found != -1)

        {

                // Creates a temporary array with existing size plus one

                double *temp = new double[size];

                // Shift each element to left from found index position to end of the array

                // Loops from found index position to end of the array

                // and assign each next index position element to current index position

                for (int c = found; c < size; c++)

                        dArray[c] = dArray[c + 1];

                // Loops till end of the existing array

                // Assign each element of the existing array to temp array

                for (int c = 0; c < size; c++)

                        temp[c] = dArray[c];

                // Decrease the size by one

                size--;

                delete[] dArray; // deallocating the array

                // Resize the existing array with new size

                dArray = new double[size];

                // Loops till end of the array minus one term

                // and assign each element of the temp array to existing array

                for (int c = 0; c < size; c++)

                        dArray[c] = temp[c];

        }// End of if condition

         // Otherwise number not found

        else

                cout << "\n The number " << number << " not found.";

}// End of function removeNumber

//end of varArray.cpp

//main.cpp

#include <iostream>

#include "vararray.h"

using std::cout; using std::endl;

void testfunc(varArray); // function to test pass-by-value for varArray

int main(){

   varArray a1;

   // testing regular member functions

   a1.addNumber(1.);

   a1.addNumber(2.);

   a1.addNumber(3.);

   a1.addNumber(3.); // trying to add duplicate, should not add it

   cout << "a1 size is after number addition is: " << a1.arraySize() << endl;

   if(a1.check(1.) != -1) // check() returns -1 if number not present

      cout << "1 is present in the array" << endl;

   if(a1.check(5.) != -1)

      cout << "5 is present in the array" << endl;

   cout << "a1 before removal of 2.0: "; a1.output();

   a1.removeNumber(2.);

   cout << "a1 after removal of 2.0: "; a1.output();

   // uncomment this when you debugged the first part

   testfunc(a1); // testing copy constructor

   cout << "a1 after testfunc call: ";

   a1.output(); // if destructor is implemented correctly

                // this should print properly after testfunc completes

   varArray a2, a3;

   a3=a2=a1; // testing stackability of the overloaded assignment

   cout << "a3 after stackable assingment: ";

   a3.output();

   a3=a3; // testing protection against self-assingment

   cout << "a3 after self-assignment: ";

   a3.output();

   return 0;

}

// tests pass-by-value for object of class varArray

void testfunc(varArray va){ // copy constructor is invoked on "va"

    cout << "parameter va: ";

    va.output();

} // destructor is invoked when "va" goes out of scope

//end of main.cpp

Output:

The number found at: 2 Cannot add duplicate number.a1 size is after number addition is: 3 1 is present in the array al before removal of 2.0: Your numbers: 1 2 3 al after removal of 2.0: Your numbers: 1 3 parameter va: Your numbers: 1 3 al after testfunc call: Your numbers: 1 3 a3 after stackable assingment: Your numbers: 1 3 a3 after self-assignment: Your numbers: 1 3