Search

12.10 — Printing inherited classes using operator<<

Consider the following program that makes use of a virtual function:

By now, you should be comfortable with the fact that b.print() will call Derived::print() (because b is pointing to a Derived class object, Base::print() is a virtual function, and Derived::print() is an override).

While calling member functions like this to do output is okay, this style of function doesn’t mix well with std::cout:

In this lesson, we’ll look at how to override operator<< for classes using inheritance, so that we can use operator<< as expected, like this:

The challenges with operator<<

Let’s start by overloading operator<< in the typical way:

Because there is no need for virtual function resolution here, this program works as we’d expect, and prints:

Base
Derived

Now, consider the following main() function instead:

This program prints:

Base

That’s probably not what we were expecting. This happens because our version of operator<< that handles Base objects isn’t virtual, so std::cout << bref calls the version of operator<< that handles Base objects rather than Derived objects.

Therein lies the challenge.

Can we make Operator << virtual?

If this issue is that operator<< isn’t virtual, can’t we simply make it virtual?

The short answer is no. There are a number of reasons for this.

First, only member functions can be virtualized -- this makes sense, since only classes can inherit from other classes, and there’s no way to override a function that lives outside of a class (you can overload non-member functions, but not override them). Because we typically implement operator<< as a friend, and friends aren’t considered member functions, a friend version of operator<< is ineligible to be virtualized. (For a review of why we implement operator<< this way, please revisit lesson 9.4 -- Overloading operators using member functions).

Second, even if we could virtualize operator<< there’s the problem that the function parameters for Base::operator<< and Derived::operator<< differ (the Base version would take a Base parameter and the Derived version would take a Derived parameter). Consequently, the Derived version wouldn’t be considered an override of the Base version, and thus be ineligible for virtual function resolution.

So what’s a programmer to do?

The solution

The answer, as it turns out, is surprisingly simple.

First, we set up operator<< as a friend in our base class as usual. But instead of having operator<< do the printing itself, we delegate that responsibility to a normal member function that can be virtualized!

Here’s the full solution that works:

The above program works in all three cases:

Base
Derived
Derived

Let’s examine how in more detail.

First, in the Base case, we call operator<<, which calls virtual function print(). Since our Base reference parameter points to a Base object, b.print() resolves to Base::print(), which does the printing. Nothing too special here.

In the Derived case, the compiler first looks to see if there’s an operator<< that takes a Derived object. There isn’t one, because we didn’t define one. Next the compiler looks to see if there’s an operator<< that takes a Base object. There is, so the compiler does an implicit upcast of our Derived object to a Base& and calls the function (we could have done this upcast ourselves, but the compiler is helpful in this regard). This function then calls virtual print(), which resolves to Derived::print().

Note that we don’t need to define an operator<< for each derived class! The version that handles Base objects works just fine for both Base objects and any class derived from Base!

The third case proceeds as a mix of the first two. First, the compiler matches variable bref with operator<< that takes a Base. That calls our virtual print() function. Since the Base reference is actually pointing to a Derived object, this resolves to Derived::print(), as we intended.

Problem solved.

12.x -- Chapter 12 comprehensive quiz
Index
12.9 -- Dynamic casting

8 comments to 12.10 — Printing inherited classes using operator<<

  • Prado

    Typo:

    You wrote "operator<&lt" instead of "operator<<"

  • Sangita gupta

    Hi Alex,

    In your solution example, I have a doubt. I think friend function does not get inherited, then how does base class operator<<() function gets called?

    • Alex

      Subclasses don’t inherit friend associations (although our operator<&lt is a friend of Base, that operator is not a friend of Derived just because Derived inherits Base).

      But that isn’t relevant here. What is relevant here is that an object of type Derived can be trivially upcast to an object of type Base, so there is an version of operator<&lt that can matches our function call to std::cout << d.

  • Surya

    Just out of curiosity. Can I do this?

    • Alex

      You can. But this is poor code for extensibility. Consider what would happen if you had a Derived2 that also derived from Base. If you passed in a Derived2, it will tell you it’s a base when it’s actually a Derived2. That’s why if you need to do this kind of class identification, it’s generally better to use a virtual function.

  • Sandeep

    Hi Alex,

    I have same query as above if derived have not any function (operator<<) then how it will call from Derived ref.

    #include <iostream>
    using namespace std;
    class Base
    {
    public:
        Base(){    }
        virtual void print() const
        {
            cout<< "Base";
        }
        
        friend ostream& operator<<(ostream &out, const Base &b)
        {
            out<< "Base Overload  :: ";
            b.print();
            return out;
        }
    };
    class Derived : public Base
    {
    public:
        Derived() : Base() {}
        virtual void print() const
        {
            cout<< "Derived";
        }
    /*    friend ostream& operator<<(ostream& out, const Derived &b)
        {
            cout<< "Derived Overload" ;
            b.print();
            return out;
        }*/
    };
    int main()
    {
        Derived d;
        Derived &b = d;
        cout<<"B is "<<b<<endl;
        return 0;
    }

    • Alex

      This is easily answered by trying it.

      In this case, because there is no D::operator<<, it will call B:operator<<. B::operator<< will then call virtual function print(), which will resolve to D::print().

Leave a Comment

Put C++ code inside [code][/code] tags to use the syntax highlighter