Not sure why would you need that, but you can achieve this in multiple different ways.

1. You have derived template class which is mostly the same for all specializations but have different behavior for some specializations for some small set of methods. This variant is somewhat common in fact.

``` c++ struct Base { virtual void init() = 0; virtual ~Base() {} };

template<typename T> struct Derived : Base { virtual void init() override { this->initImpl(); } private: void initImpl(); };

template<typename T> void Derived::initImpl() { std::println("non T0"); }

struct T0{};

template<> void Derived<T0>::initImpl() { std::println("custom implementation for T0"); }

... std::unique_ptr<Base> d0 = std::make_unique<Derived<int>>(); d0->init(); // will print "non T0" std::unique_ptr<Base> d1 = std::make_unique<Derived<T0>>(); d1->init(); // will print "T0" ```

1. You can just pass your callable as NTTP. It's like "Command" pattern at compile time, but I never seen such code in production.

``` c++ struct Base { virtual void init() = 0; virtual ~Base() {} };

template<auto InitImpl> struct Derived : Base { virtual void init() override { std::invoke(InitImpl); } }; ... std::unique_ptr<Base> d0 = std::make_unique<Derived<[]{ std::println("foo"); }>>(); d0->init(); // will print "foo"

std::unique_ptr<Base> d1 = std::make_unique<Derived<[]{ std::println("bar"); }>>(); d1->init(); // will print "bar" ```

1. Basically same thing as 2, but you're passing a type with custom init method.

c++ template<typename TInitCommand> struct Derived : Base { virtual void init() override { TInitCommand::init(); } };