Topic 19: C++ Operator Overloading

Synopsis

• Assigning to a class^¤ object
   
• Overloading operator=
   
• Operator overloading^¤ via member^¤ functions
   
• A slight problem of ordering
   
• Operator overloading^¤ via non-member^¤ functions
   
• How does the compiler know which operator function to use?
   
• Friend^¤ functions
   
• Which operators can be overloaded?
   
• Which operators can't be overloaded?
   
• Which operators should be overloaded?
   
• An important use of operator overloading^¤
   
• Reading

Assigning to a class^¤ object

• Assignment to an object (ob1 = ob2;) works as you would expect: each member^¤ of ob1 is assigned to the corresponding member^¤ of ob2
   
• But suppose we wanted to be able to assign objects of different types to each other (the way we can assign ints to floats and vice-versa)?
   
• For example:

  Coefficient c (0.5);
  
  // AND LATER...
  
  c = 0.75;
  

• As a first step, we could observe that the Coefficient::SetValue(double) member^¤ function already does the job:

  class Coefficient
  {
  public:
          Coefficient(double initVal)
          { myValue = initVal; myAccesses = 0; }
  
          double GetValue(void) const
          { myAccesses++; return myValue; }
  
          bool SetValue(double v)
          {
                  myAccesses++;
                  if (v<0 || v>1) { return false; }
                  myValue = v;
                  return true;
          }
  private:
          double myValue;
          mutable int myAccesses;
  };
  
  Coefficient c (0.5);
  
  // AND LATER...
  
  c.SetValue(0.75);
  

• So all we need is some way to make the normal assignment syntax (c = val) actually call c.SetValue(val)

Overloading operator=

• In C++ we can cause an operator to invoke a member^¤ function by giving that member^¤ function a special name (of the form: operator<symbol>
   
• Hence for the assignment operation, the special name is: operator=.
   
• So, by changing the member^¤ function name from Coefficient::SetVal to Coefficient::operator= we get the desired effect:

  class Coefficient
  {
  public:
          Coefficient(double initVal)
          { myValue = initVal; myAccesses = 0; }
  
          double GetValue(void) const
          { myAccesses++; return myValue; }
  
          bool operator= (double v)
          {
                  myAccesses++;
                  if (v<0 || v>1) { return false; }
                  myValue = v;
                  return true;
          }
  private:
          double myValue;
          mutable int myAccesses;
  };
  
  Coefficient c (0.5);
  
  // AND LATER...
  
  c = 0.75;	// ACTUALLY CALLS: c.operator=(0.75);
  

Operator overloading^¤ via member^¤ functions

• Likewise, we could overload the += and -= operators for class^¤ Coefficient:

  class Coefficient
  {
  public:
  	// ...AS BEFORE...
  
  	bool operator+=(double addval)
          { return addValue(addval); }
  
  	bool operator-=(double subval)
  	{ return addValue(-subval); }
  
  private:
  	bool addValue(double v)
          {
                  myAccesses++;
                  if (myVal+addval<0 || myVal+addval>1)
                          return false;
                  myValue += v;
                  return true;
          }
  };
  

• Operators can be overloaded within the same class^¤ (just like regular functions):

  class Coefficient
  {
  public:
  	// ...AS BEFORE...
  
          bool operator= (double v)
          {
                  myAccesses++;
                  if (v<0 || v>1)
                          return false;
                  myValue = v;
                  return true;
          }
  
  	bool operator= (char* str)
  	{
                  if (!strcmp(str,"default"))
          		return operator=(0.5);
  	        else if (!strcmp(str, "max")
          		return operator=(0.0);
                  else if (!strcmp(str, "min"))
          		return operator=(1.0);
                  else
          		return false;
  	}
  
  private:
  	// ...AS BEFORE...
  };
  
  Coefficient c(0.6);
  
  c = 0.75;
  
  c = "max";
  
  c = "default";
  

A slight problem of ordering

• Because C++ translates expressions like <var> <op> <value> into <var>.operator<op>(<value>), there's a major problem if we want to overload an operator where the first operand isn't a class^¤ type.
   
• For example, suppose we wanted to be able to add Coefficient objects together (producing new Coefficient objects). We could write:

  class Coefficient
  {
  public:
  	// ...AS BEFORE...
  
          Coefficient operator+ (Coefficient c)
          {
                  Coefficient sum (this->myValue + c.myValue);
  	        return sum;
          }
  
          Coefficient operator+ (double d)
          {
                  Coefficient sum (this->myValue + d);
  	        return sum;
          }
  
  private:
  	// ...AS BEFORE...
  };
  

• ...which would allow us to write:

  Coefficient c1 (0.25);
  Coefficient c2 (0.45);
  Coefficient c3 (0.5);
  
  c3 = c1 + c2;	// REALLY: c3.operator=(c1.operator+(c2));
  	        // CALLS: Coefficient::operator+(Coefficient)
  
  c3 = c1 + 0.4;	// REALLY: c3.operator=(c1.operator+(0.4));
  		// CALLS: Coefficient::operator+(double)
  
  // BUT NOT...
  
  c3 = 0.4 + c1;	// CAN'T CALL (0.4).operator+(c1) !!!
  

Operator overloading^¤ via non-member^¤ functions

• C++ solves this problem by allowing non-member^¤ operator functions.
   
• We can create such functions by creating the appropriate ordinary function:

  Coefficient add(double leftval, Coefficient rightval)
  {
  	Coefficient leftValAsCoeff (leftval);
  	return leftValAsCoefficient + rightVal;
  }
  

• ...and then changing its name to the appropriate operator<op> name:

  Coefficient operator+ (double leftval, Coefficient rightval)
  {
  	Coefficient leftValAsCoeff (leftval);
  	return leftValAsCoefficient + rightVal;
  }
  

• The only restrictions are that the operator function must have exactly the same number of arguments as the original operator, and at least one of those arguments must be of a user-defined class^¤ type.

How does the compiler know which operator function to use?

• When compiling an expression of the form <var> <op> <value>, the compiler does the following:
   

1. If <var> is of an inbuilt type (int, char*, etc.), the standard (inbuilt) operator is used
    
2. If <var> is of a user-defined class^¤ type (Coefficient, Vehicle, etc.), the compiler checks if there is a suitable user-defined operator<op> function defined (that is, one whose parameter is of the same type as <value>, or of a type convertable to the type of <value>). If so, that function is used
    
3. Otherwise, a compiler error is flagged
    

• Note that there are special problems if there are more than one "suitable" operator functions available. Such problems are resolved using the normal function overloading resolution rules (see "Topic 8: C++ Functions"). For example:

  class Complex
  {
  public:
  	Complex(float re, float im)
  	: myReal(re), myImag(im)
  	{}
  
  	Complex operator+(Complex c)
  	{
                  Complex sum(myReal+c.myReal, myImag+c.myImag);
  	        return sum;
  	}
  
  	Complex operator+(double re)
  	{
                  Complex sum(myReal+re, myImag);
  	        return sum;
  	}
  
  	Complex operator+(int re)
  	{
                  Complex sum(myReal+re, myImag);
  	        return sum;
  	}
  
  	float Real(void)
  	{ return myReal; }
  
  	float Imag(void)
  	{ return myImag; }
  
  private:
  	float myReal;
  	float myImag;
  };
  
  Complex operator+(Complex c1, Complex c2)
  {
  	Complex sum(c1.Real()+c2.Real(), c1.Imag()+c2.Imag());
  	return sum;
  }
  
  Complex operator+(double d, Complex c2)
  {
  	Complex sum(d+c2.Real(), c2.Imag());
  	return sum;
  }
  
  Complex c1 (1.1, 0);
  Complex c2 (9,9. 9);
  double      d  (1.1);
  int         i  (0);
  char        c  ('c');
  
  c1 + d;		// CALL Complex::operator+(double)
  d + c1;		// CALL ::operator+(double,Complex)
  
  c1 + i;		// CALL Complex::operator+(int)
  i + c1;		// CALL ::operator+(double,Complex)
  
  c1 + c;		// AMBIGOUS: Complex::operator+(double)
  		//       OR: Complex::operator+(int)
  		// EQUALLY GOOD (1 CONVERSION EACH)
  
  c + c1;		// CALL ::operator+(double,Complex)
  
  c1 + c2;	// AMBIGOUS: Complex::operator+(Complex)
  		//       OR: ::operator+(Complex,Complex)
  		// EQUALLY GOOD (NO CONVERSION FOR EITHER)
  

Friend^¤ functions

• In creating the non-member^¤ operator+ functions for the Complex class^¤ we had to rely on calls to Complex::Real() and Complex::Imag(). Why?
   
• For better efficiency it would be handy if we could tell class^¤ Complex that those non-member^¤ functions really do "belong" to the class^¤ (in the ADT sense), and therefore should have access to the private members^¤ of class^¤ objects.
   
• Note that this notion is a violation of strict encapsulation^¤ (in the name of efficiency), since we wish to allow certain non-member^¤ functions to "see inside" class^¤ objects (in order to save on function calls).
   
• If we decide to do so, we can use the friend keyword to declare that a particular non-member^¤ function has unrestricted access to a class^¤:

  class Complex
  {
  	// DECLARE THE SPECIFIED GLOBAL FUNCTION AS A FRIEND
  	// OF THIS CLASS...
  
  	friend Complex operator+(double, Complex);
  
  public:
  	Complex(float re, float im)
  	: myReal(re), myImag(im)
  	{}
  
  	// ETC. ETC. AS BEFORE...
  };
  
  Complex operator+(double d, Complex c2)
  {
  	// CAN NOW ACCESS PRIVATE MEMBERS OF c2...
  
  	Complex sum(d+c2.myReal, c2.myImag);
  	return sum;
  }
  

• Friends^¤ can only be declared in a class^¤, and friendship is neither inheritable, nor transitive.

Which operators can be overloaded?

• The following operators can be overloaded:

1. Unary operators: 
    
   +  -  *  &  ~  !  ++  --  ->  ->*
2. Binary operators: 
    
   +  -  *  /  %  ^  &  |  <<  >> 
+= -= *= /= %= ^= &= |= <<= >>= 
<  <=  >  >=  ==  !=  &&  || 
,  []  () 
new  new[]  delete  delete[]

Which operators can't be overloaded?

• There are only four: .  .*  ?:  ::
   
• But you also can't create new operators
   
• Nor can you change the meaning of operations involving only inbuilt types
   
• Nor can you change the precedence or the arity of any operator (to create unary ^ or binary !, for example)

Which operators should be overloaded?

• A philosophical question
   
• Only those for which it makes sense...
   
• ...and for which there is a genuine need...
   
• ...and which the user will expect
   
• Typically these are usually appropriate: =  <<  >>
   
• If the class^¤ implements some arithmetic type (e.g. Complex, Matrix, Vector, etc.) then the full range of (valid!) arithmetic operations on the type should also be offered

An important use of operator overloading^¤

• Because we can overload the operators << and >>, we can allow user-defined classes^¤ to perform I/O just like inbuilt types (!)
   
• For example:

  #include <iostream.h>
  
  class Complex
  {
  public:
  	Complex(float re, float im)
  	: myReal(re), myImag(im)
  	{}
  
  	friend istream& operator>>(istream&, Complex&);
  	friend ostream& operator<<(ostream&, const Complex&);
  
  private:
  	float myReal;
  	float myImag;
  };
  
  istream& operator>>(istream& in, Complex& c)
  {
  	double real, imag;
  	in >> real >> imag;
  	if (in.good())
  	{
  		c.myReal = real;
  		c.myImag = imag;
  	}
  	return in;
  }
  
  ostream& operator<<(ostream& out, const Complex& c)
  {
  	out << "(" << c.myReal << "," << c.myImag << ")";
  	return out;
  }
  

Reading

• Lippman & Lajoie

Chapter 15.


 

• Stroustrup

Chapter 11.