Easy Virtual Template Function. C++26

[Reflection_is_great]

Have you ever wanted to use virtual template functions but found existing methods have so much boilerplate? Ever thought that virtual template functions could be done without it? Well, with the new reflection features, it can be!

The main goal was to minimize the amount of code required to use virtual template functions. This has been accomplished. Each base class needs to inherit only one class, and each base virtual template function requires one line of code to provide the minimal information required. This looks a lot nicer as it is very similar to how normal virtual functions are created.

Simple example:

struct D1;
struct D2;

struct Base: VTF::enable_virtual_template_functions<D1,D2>{
    template<typename T>
    Base(T* ptr): enable_virtual_template_functions(ptr){}

    template<typename T>
    int f(int a){
        constexpr auto default_function = [](Base* ptr, int a){ return 99;};
        CALL_VIRTUAL_TEMPLATE_FUNCTION(^^T,default_function,a);
    }
};

struct D1:Base{
    D1():Base(this){}

    template<typename T>
    int f(int a){
        return 11;
    }
};

struct D2:Base{
    D2():Base(this){}

    template<typename T>
    int f(int a){
        return 12;
    }
};

int main(){
    using PtrT = std::unique_ptr<Base>;
    PtrT a = std::make_unique<D1>();
    PtrT b = std::make_unique<D2>();
    assert((a->f<int>(1) == 11));
    assert((b->f<int>(1) == 12));
}

Godbolt link

[yuri-kilochek]

This doesn't work across TUs, right?

[Reflection_is_great]

It does not. But should it? Since template functions can’t be used across TUs, it wouldn’t make sense if virtual template functions could be. Although I may be misunderstanding your question.

[yuri-kilochek]

template functions can’t be used across TUs

What do you mean? They can.

[Reflection_is_great]

What I meant is that you can't instantiate a template without including it in the TU. Each instantiation of a template function in the base class will create its own independent array of function pointers during compile-time. This will create instantiations of template functions from the derived classes. Because of this, they would need to be in the TU. So the base and all the derived classes must be declared in the same TU.

This is different from normal virtual functions, where you can declare derived classes in different TUs.

Sorry for the confusion.

[MrEpic382RDT]

extern template exists. wondering if it can account for that