Question

Here is an example of a class that is made available for the + operation.

class A
{
public:
   int *array;

   A()
   {
      array = new int[10];
   }

   ~A()
   {
      delete[] array;
   }

   A operator+ (const A &b)
   {
      A c;
      for(int i=0; i<10; i++)
         c.array[i] += array[i] + b.array[i];
      return c;
   }
};

int main()
{
   A a,b,c,d;

   /* puts some random numbers into the arrays of b,c and d */
   a = b+c+d;
}

Will a run the destructor before copying the result of b+c+d or not? If not, how do I make sure no memory is leaked?

The + operator overload is designed this way such that no operand is modified.

Answer 1

You need to add an equals operator to A. Also, you will likely want to create a copy constructor.

When a becomes the return from b+c+d, the array pointer in a gets over written without delete[] ever being called on it. You need to make an operator= that deletes the array.

An example of an operator= is below:

A& operator=(A const& a)
{
    if (&a != this) {
        int* tmp = this->array;
        this->array = new int[10];
        //copy a.array to this->array
        delete[] tmp;
    }
    return *this;
}

There’s a lot of subtleties in this if you’re new to operator=.

In particular, the check whether or not a is equal to this is necessary because it’s perfectly valid to write:

A a;
a = a;

This would cause a pointless copy, and in most cases of operator= will cause bugs.

The other subtlety is less of a requirement than that one and more of a coding style (though a very wide spread standard). When copying something that is dynamically allocated, you always want to allocate and copy before you release. That way, if new throws an exception (or something else fails), the object is still in a stable state, though with it’s old data instead of the new expected dated.