Why polymorphism is not working in this case?

Question

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 ?
}

Answer 1

virtual void print(std::ostream& out) const 

is not overridden by

void print(std::ostream& out)

(because of const).

Answer 2

You forgot the const on the definition of print in the derived class.