#include <boost/shared_ptr.hpp>

template <typename T_Class>
struct pimpl {

    class implementation;

    struct polymorphic_base {

    protected:
        explicit polymorphic_base( typename pimpl::implementation * i ) : _impl( i ) {}

        typename pimpl::implementation * impl() { return _impl.get(); }
        const typename pimpl::implementation * impl() const { return _impl.get(); }
    private:
        boost::shared_ptr<typename pimpl::implementation> _impl; 
    };

    template <typename T_Base>
    struct derived_from : T_Base {
        typedef T_Base base;
    protected:
        explicit derived_from( typename pimpl::implementation * i )
            : base( (typename pimpl<base>::implementation*)i ) {}
        typename pimpl::implementation * impl() {
            return (typename pimpl::implementation*)T_Base::impl();
        }
        const typename pimpl::implementation * impl() const {
            return (const typename pimpl::implementation*)T_Base::impl();
        }
    };

};

class Base : protected pimpl<Base>::polymorphic_base {
    typedef pimpl<Base>::polymorphic_base base;
public:
    Base();

    void f();
    void f() const;

protected:
    explicit Base( pimpl<Base>::implementation * i ) : base( i ) {}
};

class Derived : public pimpl<Derived>::derived_from<Base> {
    typedef pimpl<Derived>::derived_from<Base> base;
public:
    Derived();

    void g();
    void g() const;
};

template <>
class pimpl<Base>::implementation {

};

Base::Base() : base( new pimpl<Base>::implementation ) {}

void Base::f() {
    pimpl<Base>::implementation * i = impl();
    //implementation * ii = impl(); // Error: 'implementation' undefined???
}

void Base::f() const {
    const pimpl<Base>::implementation * ci = impl();
    //pimpl<Base>::implementation * i = impl(); // Error: can't convert 'const implementation*' -> 'implementation*': Good.
}

template <>
class pimpl<Derived>::implementation : pimpl<Base>::implementation {

};

Derived::Derived() : base( new pimpl<Derived>::implementation ) {}

void Derived::g() {
    pimpl<Derived>::implementation * i = impl();
    //implementation * ii = impl(); // Error: 'implementation' undefined??
}

void Derived::g() const {
    const pimpl<Derived>::implementation * ci = impl();
    //pimpl<Derived>::implementation * i = impl(); // Error: can't convert 'const implementation*' -> 'implementation*': Good.
}

int main() {

    Base b;
    Derived d;

    const Base cb;
    const Derived cd;

    b.f();
    cb.f();

    d.f();
    cd.f();

    d.g();
    cd.g();

    return 0;
}