+ Operator

[volyx]

I have a question, im making + operator for one of my classes, the code is this:

const Color & operator + ( const Color & a, const Color & b );

The question is: i have to make a new object so i can return it, however if i make an auto object it will be deleted after the function ends ( right ? ) and if i make it with

Color * color = new Color;

It wont be deleted after assignement... So how would i do it? i dont really want to pass the Color class entirely since it isnt small enough.


thanks

[sean]

i dont really want to pass the Color class entirely since it isnt small enough.

I think this would be a perfect application for pointers, don't you?

[skorman00]

you could return a Color object instead of a const Color &. If it is really that big though, you may want to make an Add function that takes 2 inputs and the output as parameters.

[Thantos]

you could return an auto_ptr instead of a regular pointer. That way when the auto_ptr goes out of scope the item pointed to will be freed

[jlou]

I'm not sure why you would want to return a reference, pointer, auto_ptr, or anything else besides a Color object. Is your Color class really that big? You are going to have to create a new object anyway (that's what the operator+ generally does), and you normally want to follow the same principles as the operator has on built-in types.

In his Exceptional C++ book, Herb Sutter has the following canonical form of operator+ (and operator +=) for some type T:

T& T::operator+=( const T& other )
{
  // ... Do your adding here - add other's properties to this - jlou
  return *this;
}

const T operator+( const T& a, const T& b )
{
  T temp( a );
  temp += b;
  return temp;
}

Notice that you must have a working copy constructor for this to work. Some benefits include making sure that anytime you need to change how two Colors are added, you only have to change it in one place and both operator+= and operator+ are automatically updated and consistent. Also notice that elsewhere in your code, you should probably use += instead of + where you can if you are concerned with performance.

Also, in More Effective C++, Scott Meyers mentions that changing the operator+ to this:

const T operator+( const T& a, const T& b )
{
  return T(a) += b;
}

might make it easier for the compiler to optimize away a temporary variable and avoid a call to the copy constructor.