C / C++ / MFC

class array
{
private:
  int  n_MaxLength;
  int  n_array;

  bool Clone   (const array& rhs);
  bool Destroy ();
public:
  array ();
  ~array ();

  array (const array& rhs);
  array& operator=(const array& rhs);

  ...
  //Other functions like setmaxlength, setItem and so on.
};

array ();
{
  // start out with an initial size of 10
  n_MaxLength = 10;
  n_array = new int[10];
}

~array ();
{
   delete[] n_array;
   n_array = NULL;
}

array (const array& rhs)
{
  n_MaxLength = rhs.n_MaxLength;
  //Allocate space for the dynamic array.
  n_array = new int[n_MaxLength];
  //Verify that the memory was properly allocated
  if (NULL != n_array)
  {
  //Copy the contents from rhs into this array.
    memcpy(n_array, rhs.n_array, sizeof(int) * n_MaxLength);
  }
}

  // the assignment operator always returns a reference to this object (*this) in order
  // to allow operations like this to succeed in C++:  a = b = c = d;
  // Otherwise only this opertion would succeed a = b;
  array& operator= (const array& rhs)
  {
    //Check that rhs is not = to this.  If it is simply return.  There is no 
    //sense in trying to copy over ourselves.
    if (this == &rhs)
    {
      return *this;
    }
    //The test above was performed, because this code will delete the current
    //memory in this object.  If we are copying to ourselves, the memory will have been
    //deleted, and the new values that we copy to ourselves will be garbage.
//Delete Code
    delete[] n_array;
    n_array = NULL;
//End Delete Code

//Copy Code
    //Copy the new values
    n_MaxLength = rhs.n_MaxLength;
    //Allocate space for the dynamic array.
    n_array = new int[n_MaxLength];
    //Verify that the memory was properly allocated
    if (NULL != n_array)
    {
    //Copy the contents from rhs into this array.
      memcpy(n_array, rhs.n_array, sizeof(int) * n_MaxLength);
    }
//End Copy Code
    //Return a reference to this pointer.
    return *this;
  }

//Destroy private function.
void Destroy()
{
   delete[] n_array;
   n_array = NULL;
}
//Clone, private function
void Clone()
{
  //Copy the new values
  n_MaxLength = rhs.n_MaxLength;
  //Allocate space for the dynamic array.
  n_array = new int[n_MaxLength];
  //Verify that the memory was properly allocated
  if (NULL != n_array)
  {
  //Copy the contents from rhs into this array.
    memcpy(n_array, rhs.n_array, sizeof(int) * n_MaxLength);
  }
}

//Destructor
~array ();
{
   Destroy ();
}

//Copy constructor
array (const array& rhs)
{
  Clone();
}

//assignment operator
array& operator= (const array& rhs)
{
  //Check that rhs is not = to this.  If it is simply return.  There is no
  //sense in trying to copy over ourselves.
  if (this == &rhs)
  {
    return *this;
  }
  //Delete dynamic memory.
  Destroy();

  //Copy rhs into this.
  Clone();

  //Return a reference to this pointer.
  return *this;
}