SimpleClass.h

```
class SimpleClass
{
    int i;

    public:
    SimpleClass() : i(0) {}
    SimpleClass(int j) : i(j) {}
    friend std::ostream& operator<<(std::ostream&, const SimpleClass&);
};

```

SimpleClass.cpp

```
#include <ostream>
#include "SimpleClass.h"

std::ostream& operator<<(std::ostream& out, const SimpleClass& obj)
{
    out << "SimpleClass : " << obj.i << '\n';
    return out;
}

```

Base and Derived Classes.h

```
class BaseClass
{
    protected:
    int i;

    public:
    BaseClass() : i(0) {}
    BaseClass(int j) : i(j) {}
    virtual void print(std::ostream& out) const { out << "BaseClass : " << i << '\n'; }
};

class DerivedClass : public BaseClass
{
    int j;

    public:
    DerivedClass() : BaseClass(), j(0) {}
    DerivedClass(int m, int n) : BaseClass(m), j(n) {}
    void print(std::ostream& out) { out << "DerivedClass : " << i << ' ' << j << '\n'; }
};

std::ostream& operator<<(std::ostream&, const BaseClass&);

```

Base and Derived Classes.cpp

```
#include <ostream>
#include "Base and Derived Classes.h"

std::ostream& operator<<(std::ostream& out, const BaseClass& obj)
{
    obj.print(out);
    return out;
}

```

main.cpp

```
#include <iostream>
#include "SimpleClass.h"
#include "Base and Derived Classes.h"

int main()
{
    SimpleClass simple(10);
    std::cout << simple;
    BaseClass base(100);
    std::cout << base;
    DerivedClass derived(100, 200);
    std::cout << derived;                   //  Doesn't call derived.print(), but base.print() instead. Why ?
}

```