Question

I’m trying to follow a tutorial here: regarding overloading operators, and I’ve found something that’s really confused me.

There was a previous question on this very website here where this tutorial was discussed, namely regarding how the variables in the class were preserved because the whole class was passed back by value.

Whilst experimenting with the class definition I toyed with making the integer variables pointers (perhaps not sensible – but just to experiment!) as follows:

class CVector {  

  int* x;
  int* y;

  public:

  CVector () {};
  CVector (int,int);
  CVector operator + (CVector);
  ~CVector ();
};

In the class constructor I allocate memory for the two integers, and in the class deconstructor I delete the allocated memory.

I also tweak the overloaded operator function as follows:

CVector CVector::operator+ (CVector param) {
  CVector temp;
  *temp.x = *x + *param.x;
  *temp.y = *y + *param.y;
  return (temp);   
}

For the original code, where the class has simple integer variables the return by value of the entire class completes successfully.

However, after I change the variables to int pointers, the return by value of the class does not complete successfully as the integer variables are no longer intact.

I assume the deconstructor is being called when the temporary CVector goes out of scope and deletes these member integer pointers, but the class itself is still returned by value.

I’d like to be able to return by value the CVector with the memory allocated to its member variables intact, whilst ensuring the temporary CVector is correctly deleted when it goes out of scope.

Is there any way this can be done?

Many thanks!

Answer 1

The problem is that you are not following the rule of the three, which basically boils down to: *if you manage resources, then you should provide copy constructor, assignment operator and destructor for your class*.

Assuming that on construction you are allocating memory for the pointers, the problem is that the implicit copy constructor is shallow, and will copy the pointers, but you probably want a deep copy. In the few cases where you do not want a deep copy, control of the manage shared resource becomes more complicated, and I would use a shared_ptr rather than trying to do it manually.