More Operator Overload

• In some sense the overload of the stream insertion operator is strange
  • This is actually the bitwise shift left
  • But apparently Stroustrup early on showed this as an example of operator overload.
  • So it has a double meaning.
• Scott Meyers in Effective C++ says "Make interfaces easy to use correctly and hard to use incorrectly".
  • This includes don't make the operators do unexpected things.
  • What do you expect + to do?
  • For a body part does + mean anything?
• You can overload the + operator.
  • The prototypes are
    • T operator +(const T&, const T&)
    • T operator +(const T&, const E&)
    • Since our enum is an int like thing, we probably don't need the constant reference, we could just pass by value.
    • So I will use the second to implement a BodyPartT + size_t

      BodyPartT operator + (BodyPartT a, size_t  b);
      
      BodyPartT operator + (BodyPartT a, size_t b){
         size_t offset{static_cast(a)};
         BodyPartT returnValue{BodyPartT::NONE};
      
         offset += b;
         if (offset <= static_cast(BodyPartT::NONE)) {
            returnValue = static_cast(offset);
         }
      
         return returnValue;
      } 

    • Notice I am trying to be careful here so I don't overflow the BodyPartT.
• You can overload the two ++ operators
  • Do you know what each does?
    • ++i, increments i and returns the new value
    • i++, returns the new value then increments i.
  • T & operator ++ () // ++i
  • T operator ++ (int) // i++
    • The two above prototypes are for class member functions.
    • Since they are in a class, this refers to the item and there is no need to pass it.
    • The different prototypes identify which of the two functions you are declaring.
    • Note the int parameter is not used
      • This is just a flag to indicate which version is being called.
      • Return types are not part of the function signature, which is used for overloading.
      • Since there is no identifier associated with it the compiler will not complain.
  • For enums the prototypes are
    • T & operator ++ (T & ) // ++i
    • T operator ++ (T &, int) // i++
    • Since this is not a class, you need to pass the value to change in.

    • // ++i
      BodyPartT & operator++(BodyPartT & b) {
          b = b + 1;
          return b;
      }
      
      // i++
      BodyPartT operator++(BodyPartT & b, int) {
          BodyPartT tmp{b};
          b = b + 1;
          return tmp;
      }

• +=
  • The class prototype
    • T& operator += (const T &);
    • T& operator += (const E &);
  • For enums we will use
    • T& operator += (T &, const T&)
    • T& operator += (T &, const E&)
  • This changes the value of the first parmeter, so it must be a reference.
  • This implementation returns a reference because = is c++ is strange.
    • Like stream insertion you can chain a group of them.
    • a = b = c = d += e is legal

  • BodyPartT & operator +=(BodyPartT & a, size_t b) {
         a = a + b;
         return a;
    } 

• The unary minus (-b)
  • Class: T operator - () const;
  • Enum T operator - (T)
  • In this case this probably shouldn't be done.
    • What does -head mean?
    • But I wanted to show how, so I implemented it.

  • BodyPartT operator -(BodyPartT b) {
        BodyPartT rv{BodyPartT::NONE};
    
        size_t count{static_cast<size_t>(BodyPartT::NONE)-1};
        size_t offset{static_cast<size_t>(b)};
    
        if (count >= offset) {
            rv = static_cast<BodyPartT>(count-offset);
        }
    
        return rv;
    } 

• Overloading in a class is easier. We will do this soon.