Thread: Returning an object with a dynamic pointer

laserlight,

I would love to use a vector, but this little snippet is part of a course I'm taking (universities love to reinvent the wheel for assignments

What I can't seem to figure out is this type of code works fine if the class elements are already defined (for instance, if I was using an array, instead of a pointer), but blows up when I try to do it this way :P

I thought I did that with the snippet, although the snippet will not compile by itself... Here is the full:

PtrandRef.h

Code:

#include <iostream>


using namespace std;

class PtrandRef{
private:
	int maxSize;
	int length;
	int *elementArray;

public:
	PtrandRef();                                  //Default Constructor
	PtrandRef(int size = 10);                     //Constructor with parameter
	PtrandRef(const PtrandRef& obj);              //Copy Constructor

	~PtrandRef();                                
	//Destructor
    //Delete all the elements from the array
	//Postcondition: Memory allocated for the array is released


	void print() const;                
	//Function to output array
	//Precondition:The array must exist
	//Postcondition: The elements of the array are printed on the standard output device

    const PtrandRef& operator=(const PtrandRef&);
	//Function to overload the assignment operator

    const PtrandRef& operator+        
        	(const PtrandRef&);
   //overload the operator +
   //Precondition: The array must exist and the length is 10
   //Postcondition: The sum of elements in the array is computed

    void removeAt(int location);
	//Function to delete value from the array
	//Precondition: The array must exist and the length is 10
	//Postcondition: If found, element is deleted from the array and the length is decremented by one;otherwise, an appropriate message is printed

    void changeAt(int location, int value);
	//Function to change an element in the array at a certain location to another given value
	//Precondition: The array must exist and the length is 10
	//Postcondition: the element of the array in a certain location is changed to another given value, and the new array is displayed
	//if the position is out of range, print error message, and the elements in the array are unchanged

    void insertAt(int location, int value);
	//Function to insert newItem in the array
	//Precondtion: The array must exist and must be within the length of 10
	//Postcondition: new value is inserted in the array and the length is increamented by one.

    int minimumAt();
	//Function to compute the minimum value of the array
	//Precondition: The array must exist and the length is 10
	//Postcondition: the minimum value is returned

    void sort();
	//Function to sort the values in the array in an increasing order
	//Precondition: The array must exist and the length is 10
	//Postcondition: Values are sorted in an increasing order in the array and the array length is unchanged.

};

PtrandRef.cpp

Code:

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cassert>
#include "PtrandRef.h"

using namespace std;


	PtrandRef::PtrandRef()
	{

	}

	PtrandRef::PtrandRef(int size)
	{
            length = 0;
            if(size <= 0)
            {
            	cout << "Array size must be positive." << endl;
            	cout << "Creating an array of size 10." << endl;
            	maxSize = 10;
            }
            else
            	maxSize = size;

            elementArray = new int[maxSize];
	}

	PtrandRef::PtrandRef(const PtrandRef& obj)
	{
		maxSize = obj.maxSize;
		length = obj.length;
		elementArray = new int[maxSize];

		for(int i = 0; i < maxSize; i++)
			*(elementArray + i) = *(obj.elementArray + i);

	}

	PtrandRef::~PtrandRef()
	{
		//To be implemented
		delete [] elementArray;
	}



	void PtrandRef::print() const
	{
             if(length == 0)
            	 cout << "Array is empty." << endl;
             else
             {
            	 for(int i = 0; i < length; i++)
            		 cout << *(elementArray + i) << " ";
            	 cout << endl;
             }
	}

    const PtrandRef& PtrandRef::operator=
    	(const PtrandRef& otherArray)
    {
    	if(this != &otherArray)            //avoid self-assignment
    	{
    		if(elementArray != NULL)
    		{
    			delete[] elementArray;
    			elementArray = NULL;
    			maxSize = 0;
    			length = 0;
    		}
    		maxSize = otherArray.maxSize;
    		length = otherArray.length;

    		if(maxSize != 0)
    		{
    			elementArray = new int[maxSize];

    			for(int i = 0; i <length; i++)
    				*(elementArray + i) = *(otherArray.elementArray + i);
    		}

    		else
    			elementArray = NULL;
    	}
    	return *this;

    }

    const PtrandRef& PtrandRef::operator+
        	(const PtrandRef& inPtr)
        	{
                   PtrandRef  temp(10);
		   temp = inPtr;
		   //int temp = 0;
				if (length != 10)
				{
					   cout << "The array length is not 10" << endl;
				}
				else 
				{
				   
				   	
				   for (int a = 0; a < length; a++)
					   {
						   *(temp.elementArray + a) = *(elementArray + a) + *(inPtr.elementArray + a);
					//sum += *(elementArray + a) + *(inPtr.elementArray + a);
					   }
				}
				
				return temp;
				//return sum;
        	}

   

    void PtrandRef::insertAt(int location, int value)
    {
    	if(location < 0 || location >= maxSize)
    	        	  cerr << "The location of the item to be inserted is "
    	        	       << "out of range." << endl;
    	          else
    	        	  if(length >= maxSize)      //array is full
    	        		  cout << "Cannot insert in a full list. " << endl;
    	        	  else
    	        	  {
    	        		  for(int i = length; i > location; i--)
    	        			  *(elementArray + i) = *(elementArray + i - 1);

    	        		  *(elementArray + location) = value;

    	        		  length ++;
    	        	  }
    }

    void PtrandRef::removeAt(int location)
    {
         if (length != 10)
		 {
			 cerr << "The array length is not 10" << endl;
		 }
		 else 
		 {

			 for (int i = location; i < maxSize - 1; i++)
			 {
				 *(elementArray + location) = *(elementArray + location + 1);
			 }
			 length--;
		 }


    }

    void PtrandRef::changeAt(int location, int value)
    {
          if(location < 0 || location >= length)
        	  cerr << "The location of the item to be replaced is "
        	       << "out of range." << endl;
          else
        	  *(elementArray + location) = value;
    }

    int PtrandRef::minimumAt()
    {
        int min = 0;	//temp variable for holding minimum   
		if (length != 10)
		{
		   cerr << "Array length is not 10. Cannot compute minimumAt" << endl;
		}
		else
		{
			min = *elementArray; //set to the first element
			for (int i = 0; i < length; i++)
			{
				if (*(elementArray + i) < min)
					min = *(elementArray + i);
			}
			return min;
		}

    }

    void PtrandRef::sort()                         //extra credits
    {
           if (length != 10)
		   {
			   cerr << "Sort: Array length is not 10. Cannot compute." << endl;
		   }
		   else
		   {
				int temp;	
			   for (int i=0; i < length; i++)
				{
					for (int j= i+1; j < length; j++)
					{
						if (*(elementArray + i) > *(elementArray + j))
						{
							temp = *(elementArray + j);
							*(elementArray + j) = *(elementArray + i);
							*(elementArray + i) = temp;
						}
					}
			   }
		   }
    }

Driver.cpp

Code:

#include <iostream>
#include "PtrandRef.h"

int main()
{
	PtrandRef array(10);
    PtrandRef array1(10);        
	PtrandRef array2(10);

	int counter;
	int number;

	int value;
	int location;

	cout << "Enter 10 integers: ";

	for(counter = 0; counter < 10; counter++)
	{
		cin >> number;
		array.insertAt(counter, number);
	}

	cout << endl;

	cout << "The array you entered is: ";
	array.print();
	cout << endl;

        array1 = array;
        cout <<"After assigning array to array1, array1 is:"<<endl;
        array1.print();


	cout << "Enter the value to be changed to: ";
	cin >> value;
	cout << endl;
	cout << "Enter the position to be changed: ";
	cin >> location;
	array.changeAt(location, value);
	cout << "After change the value at location "<< location <<" to value"<< value <<", the array is: "<<endl;
	array.print();
	cout << endl;

	cout << "Array + Array1 = ";
	(array + array1).print();



	cout << "Minimum of array = " << array.minimumAt() << endl;

	cout << "Sorted array: ";
	array.sort();
	array.print();

	cout << "Enter position to remove value: ";
	cin >> value;
	array.removeAt(value);
	array.print();

}

Don't worry about the commented out lines in the operator+... It's just there in case they wanted us to do something else and I have to switch the code over....

Eureaka!

Thanks for the help, guys! I read the link, then wrote a copy constructor (then noticed the program already had one-- still, was good practice...) and did as you said for returning by value. It works perfectly. Thanks for your help and your patience with my thick skull