template<class TActual>
class Base
{
public:
    TActual      & self()       { return *static_cast<TActual      *>(this); }
    TActual const& self() const { return *static_cast<TActual const*>(this); }
    
    // паттерн Шаблонный Метод: "виртуально" вызываем методы наследника
    void foo()
    {
        self().bar();
        self().buz();
    }
    
    void bar() {} // "виртуальная" функция, которую наследник может переопределить, перегрузив
    //void buz(); // "чисто виртуальная" функция - наследник обязан её определить
};

template<class TActual>
class Intermediate : public Base<TActual>
{
    void bar() {}
    void buz() {}
};

class Final : public Intermediate<Final>
{
    void bar() {}
};

class A
{
    virtual void A() = 0;
    virtual void B() = 0;
    ...
}

// небольшое количество единообразных реализаций...

// эта пусть будет на виртуальных функциях
class CommonImpl1 : public IA
{
#ifdef COMPILE_B
private: // ибо незачем наследникам вызывать то, что может быть исключено из компиляции
    virtual void B() { this->foo(); this->bar(); }
protected:
    virtual void foo();
    virtual void bar();
#endif
};

// а эта на CRTP
template<class T>
class CommonImpl2 : public IA
{
#ifdef COMPILE_B
private:
    virtual void B() { static_cast<T*>(this)->buz(); }
};

// и куча окончательных наследников
class Derived1 : public CommonImpl1 { ..... };
class Derived2 : public CommonImpl1 { ..... };
class Derived3 : public CommonImpl2<Derived3> { ..... };
template<class T> class Derived4 : public CommonImpl2<T> { ..... }; // аналог виртуальности для CRTP :)

К>// эта пусть будет на виртуальных функциях
К>class CommonImpl1 : public IA
К>{
К>#ifdef COMPILE_B
К>private: // ибо незачем наследникам вызывать то, что может быть исключено из компиляции
К>    virtual void B() { this->foo(); this->bar(); }
К>protected:
К>    virtual void foo();
К>    virtual void bar();
К>#endif
К>};

class IA{..}

template< class T >
class IB
{
public:
#ifdef USE_B
    void b()
    {
        static_cast<T*>(this)->b_impl();
    }
#endif
};

class Base : public IA, public IB<A>
{
public:
    void b_impl(){...};
};

class B: public Base, public IB<B> (?)
{
public:
    void b_impl(){...};
};

int main()
{
    Base *ca = new Base();
    Base *cb = new B();

#ifdef USE_B
    ca->b();       // <-- Base::b_impl
    cb->b();       // <-- тоже Base::b_impl
#endif

// ImplA2.cpp
//  реализация класса ImplA2

static CImplRegistrar<Impl2, ImplA2> regIt;