#include <iostream>

    /// In header
    #include <cassert>
    #include <vector>
    
    template <class, size_t> class BaseT;

    class Base {
        template <class, size_t> friend class BaseT;
    public:

        int get() const; //     -> Implement: 'int getImpl() const' in Derived

        void set(int i); // = 0 -> Implement: 'void setImpl(int i)' in Derived

    private:
        struct VTable {
            typedef int (*Getter)(void const*);
            typedef void (*Setter)(void*, int);

            VTable(): _get(0), _set(0) {}

            Getter _get;
            Setter _set;
        };

        static std::vector<VTable>& VT(); // defined in .cpp

        explicit Base(size_t v): _v(v) {}

        size_t _v;
    }; // class Base

    template <class Derived, size_t Index>
    class BaseT: public Base {
    public:
        BaseT(): Base(Index) {
            static bool const _ = Register();
            (void)_;
        }

        // Provide default implementation of getImpl
        int getImpl() const { return 0; }

        // No default implementation setImpl

    private:
        static int Get(void const* b) {
            Derived const* d = static_cast<Derived const*>(b);
            return d->getImpl();
        }

        static void Set(void* b, int i) {
            Derived* d = static_cast<Derived*>(b);
            d->setImpl(i);
        }

        static bool Register() {
            typedef Base::VTable VTable;

            std::vector<VTable>& vt = Base::VT();

            if (vt.size() <= Index) {
                vt.insert(vt.end(), Index - vt.size() + 1, VTable());
            } else {
                assert(vt[Index]._get == 0 && "Already registered VTable!");
            }

            vt[Index]._get = &Get;
            vt[Index]._set = &Set;
            
            return true;
        }
    }; // class BaseT

    /// In source
    std::vector<Base::VTable>& Base::VT() {
        static std::vector<VTable> V;
        return V;
    } // Base::VT

    int Base::get() const {
        return VT()[_v]._get(this);
    } // Base::get

    void Base::set(int i) {
        return VT()[_v]._set(this, i);
    } // Base::set

    // 4 must be unique within the hierarchy
    class Derived: public BaseT<Derived, 4> {
         template <class, size_t> friend class BaseT;
    public:
        Derived(): _i(0) {}

    private:
        int getImpl() const { return _i; }

        void setImpl(int i) { _i = i; }

        int _i;
    }; // class Derived
    
    
    /// In action
    void print(Base const& b) { std::cout << b.get() << "\n"; }
    void set(Base& b, int i) { b.set(i); }
    
    int main() {
        Derived d;
        set(d, 4);
        print(d);
    }