Can’t Overload operator

by

When overloaded as a member function, a << b is interpreted as a.operator<<(b), so it only takes one explicit parameter (with this as a hidden parameter).

Since this requires that the overload be part of the class used as the left-hand operand, it’s not useful with normal ostreams and such. It would require that your overload be part of the ostream class, not part of your class. Since you’re not allowed to modify ostream, you can’t do that. That leaves only the global overload as an alternative.

There is, however, a fairly widely-used pattern where you overload the operator globally, but have that call a member function:

class whatever { 
    // make this public, or the global overload a friend.
    std::ostream &write(std::ostream &dest) const { 
        // write self to dest
    }
};

std::ostream &operator<<(std::ostream &os, whatever const &w) { 
     return w.write(os);
}

This is particularly useful when/if you want polymorphic behavior. You can’t make the overloaded operator polymorphic itself, but you make the member function it calls virtual, so it acts polymorphic anyway.

Edit: to (I hope) clarify the situation, you can do this a few different ways. The first and probably most obvious is to just make our write member public, and have the global operator call it. Since it is public, we don’t have to do anything special to let the operator use it:

class myClass {
public:
    std::ostream &write(std::ostream &os) const { 
        // write stuff to stream
        return os;
    }   
};

std::ostream &operator<<(std::ostream &os, myClas const &m) { 
   // since `write` is public, we can call it without any problem.
   return m.write(os);
}

A second alternative is to make write private, and declare operator<< a friend to give it access:

class myClass {
    // Note this is private:
    std::ostream &write(std::ostream &os) const { 
        // write stuff to stream
        return os;
    }

    // since `write` is private, we declare `operator<<` a friend to give it access:
    friend std::ostream &operator<<(std::ostream &, myClass const &);
};

std::ostream &operator<<(std::ostream &os, myClas const &m) { 
   return m.write(os);
}

There’s a third possibility that’s almost like the second:

class myClass {
    // Note this is private:
    std::ostream &write(std::ostream &os) const { 
        // write stuff to stream
        return os;
    }

    // since `write` is private, we declare `operator<<` a friend to give it access.
    // We also implement it right here inside the class definition though:
    friend std::ostream &operator<<(std::ostream &os, myClas const &m) { 
        return m.write(os);
    }
};

This third case uses a rather strange (and little known) rule in C++ called “name injection”. The compiler knows that a friend function can’t be part of the class, so instead of defining a member function, this “injects” the name of that function into the surrounding scope (the global scope, in this case). Even though operator<< is defined inside the class definition, it’s not a member function at all — it’s a global function.

More Related Contents:

  1. What are the basic rules and idioms for operator overloading?
  2. Operator[][] overload
  3. How should I write ISO C++ Standard conformant custom new and delete operators?
  4. Overloading member access operators ->, .*
  5. Why override operator()?
  6. Overload resolution failure when streaming object via implicit conversion to string
  7. What’s the right way to overload operator== for a class hierarchy?
  8. How to code a modulo (%) operator in C/C++/Obj-C that handles negative numbers
  9. Why can’t you overload the ‘.’ operator in C++?
  10. overloading new/delete
  11. Why should the assignment operator return a reference to the object?
  12. How can I reliably get an object’s address when operator& is overloaded?
  13. Why cannot a non-member function be used for overloading the assignment operator?
  14. How to overload the operator++ in two different ways for postfix a++ and prefix ++a?
  15. Calling a const function rather than its non-const version
  16. Rationale of enforcing some operators to be members
  17. return value of operator overloading in C++
  18. Is there actually a reason why overloaded && and || don’t short circuit?
  19. C++ overloading array operator
  20. How to overload unary minus operator in C++?
  21. ‘friend’ functions and
  22. How do we declare a friend function with a class template into .h file and define them into a .cpp file (not all in one header file)?
  23. How do I call the original “operator new” if I have overloaded it?
  24. Operator overload which permits capturing with rvalue but not assigning to
  25. C++ why the assignment operator should return a const ref in order to avoid (a=b)=c
  26. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  27. operator
  28. Why we need to return reference to istream/ostream while overloading >> and
  29. What operators do I have to overload to see all operations when passing an object to a function?
  30. using declaration in variadic template

Leave a Comment