Overloading the stream insertion (<<) operator for a class

Question

It is often overloaded as a friend function of the class. Is there any way it can be overloaded as a member function?

Answer 1

If you wanted to badly enough, you could use a member function overload, but it's directly contrary to convention, so doing it would lead to confusion. It would also prevent chaining extraction/insertion operators, and wouldn't work for reading/writing primitive types.

The reason behind this is that invoking an operator overloaded as a member function means that x << y; is interpreted as x.operator<<(y);, so the overloaded operator has to be a member of the left operand, not the right. It's possible to do that (iostreams include such overloads for some types), but it's essentially impossible to extend (all such overloads have to be part of the iostream object when it's the left operand).

If you want to overload it as a member of the object to be read/written, you need to put the object being read/written as the left operand. This means insertion would go from left to right instead of right to left. To have at least some chance of maintaining sanity, you'd almost certainly want to use >> for insertion, and << for extraction:

class my_class {
    int x;
public:
    bool operator<<(std::istream &is) { 
        // Note the reversal here. That's because we're defining this 
        // for a `my_class` on the left, and an iostream on the right, 
        // but the existing `>>` and `<<` use the reverse of that (iostream
        // on the left).
        is >> x;
        return is.good();
    }
    bool operator>>(std::ostream &os) { 
        os << x;
        return os.good();
    }
};

my_class a;

a >> std::cout;

a << std::cin;

Note: I'm providing this answer only to point out that it's technically possible to do this, and show how. If you were starting over with a clean slate and you were really set on using member functions, I can see where you might conceivably choose this method--but even then, it's open to a lot of question.

In particular (as noted above) this would not support chaining. Since the insertion and extraction are done as member functions of the left operand, it also means it would only work for user-defined types, not any primitive types (int, short, long, float, double, bool, etc.)

Bottom line: if you want to badly enough, you can get it to work to a limited degree under limited circumstances--but neither well (no chaining) nor universally (no primitive types).