Operator Overloading

• This is chapter 15 in the book.
  • You should read the first part of the chapter (up to page 454).
  • You should refer to the other parts of the chapter as needed when you overload an operator.
• Overloading an operator allows us to supply the definition for an operator in our data types.
  • This is mostly intended for classes.
  • But there are a few that we can overload for non-class data types.
• This line of code annoys me

  BodyPartT i;
  ...
  cout << "\t" << BodyPartTToString(i) << endl; 

• Why can't I just do the following?

  BodyPartT i;
  ...
  cout << "\t" << i << endl; 

  • Because the stream insertion operator << is not defined
  • Why?
  • Because the people that implemented the standard library, (ie the stream insertion operator) don't know how to handle a BodyPartT
• But operator overload makes this possible.
  • I don't know the history, but I bet this is a retrofit.
  • Look at the table on page 541, the << is presented.
  • The prototype is T operator << (const T &, const E &)
  • This says that << takes two parameters, and returns something the same type as the first parameter.
  • Note that the column header is Sample prototypes.
  • We don't have to follow that, but we should if possible.
• Stream insertion
  • This is a bit strange, you may not have contemplated it before.
  • There is a discussion on page 468.
  • cout << i << endl;
    • cout, is an ostream , this is parameter type T
    • i is of some data type, in this case a BodyPartT and is the second parameter type E
    • The << operator returns the first parameter type, in this case a ostream.
    • So the execution of this code becomes, in some sense

      tmp = cout << i
      cout = tmp
      cout << endl

  • This gives us some insight into the parameter types for the actual operator.
    • The first type is a ostream, but it can't be a constant since we will alter the stream.
    • The return type is slightly different, it is a reference to a ostream
      • We will discuss references further in the future.
      • For now, just accept it.
  • std::ostream & operator << (std::ostream & s, const BodyPartT & part)
• Implementing the overload stream insertion operator
  • We need to put the function prototype in the header file.
  • We will implement this function in the implementation file.

  • ostream & operator << (ostream & s, const BodyPartT & part) {
          s << BodyPartTToString(part);
          return s; 

  • For now, this can be somewhat idiomatic.
• Using the overloaded stream insertion operator: just do it.