Bdtjtk

How do I work around for not having the support for templated virtual function?

I have a requirement to create a Builder/Command class which can store templated argument which is used later to call methods to do some processing.

Basically builder should be able to store templated values, maybe there is a different(more correct) way of doing it.

After setting all the values, later I want to call an execute method which will use the templated values to call an internal method.

class BuilderImpl {

public:

    virtual void execute() = 0;

    virtual int type() = 0;

private:

    // common properties here

};



template <typename T1, typename T2>

class BuilderImpl2: public BuilderImpl {

public:

    BuilderImpl2(const T1 &v1, const T2 &v2) : mVar1{v1}, mVar2{v2} {

    }



    virtual void execute() override {

        std::cout << __PRETTY_FUNCTION__ << std::endl;

    }



    virtual int type() override {

        return 2;

    }





    T1 mVar1;

    T2 mVar2;

};





template <typename T>

class BuilderImpl1: public BuilderImpl {

public:

    typedef BuilderImpl1<T> CLAZZ;



    BuilderImpl1(const T &v) : mVar1{v} {

    }



    virtual void execute() override {

        std::cout << __PRETTY_FUNCTION__ << std::endl;

    }



    virtual int type() override {

        return 1;

    }



    template <typename T2>

    std::shared_ptr<BuilderImpl> add(const T2 &v2) {

        return std::make_shared<BuilderImpl2<T, T2>>(mVar1, v2);

    }



    T mVar1;

};



class Builder {

public:

    void execute() {

        std::cout << __FUNCTION__ << std::endl;



        if (mImpl) {

            mImpl->execute();

        }

    }



    template <typename T>

    void add(const T &v) {

        if (!mImpl) {

            mImpl = std::make_shared<BuilderImpl1<T>>(v);

        } else if (mImpl->type() == 1) {

            // How do I update my implementation mImpl to point with an instance of BuilderImpl2, any trick?

            //mImpl = std::static_pointer_cast<BuilderImpl1<???>>(mImpl)->add(v);

        }

    }



protected:

    std::shared_ptr<BuilderImpl> mImpl{ nullptr };

};



void templatebuilder() {

    Builder builder;

    builder.add(10);

    builder.add(0.0);

    builder.execute();

}

It’s impossible to do this in an automatic, extensible fashion: two translation units could define types A and B, necessitating the construction of an impossible type BuilderImpl2<A,B>. (This is related to the fact that for n input types you need O(n^2) implementations.)

So you have to explicitly list the types you support for at least one side. The most direct way of doing this is with a ladder of dynamic_casts:

if(const auto p=dynamic_cast<BuilderImpl1<A>>(mImpl.get())) mImpl=p->add(v);

else if(const auto p=…) mImpl=p->add(v);

// …

else die_horribly();

(You might add a convenience method to let you write const auto p=mImpl->cast<A>().) There might be a nicer way of indexing with the dynamic type of the BuilderImpl1, but that’s a separate issue.

This is a complement to Davis's answer.

The line typedef BuilderImpl1<T> CLAZZ; let think that you are used to Java. There is a strong difference between Java and C++ here:

• Java uses generics with type erasure. There is only one class for any specialization, and simply controls are applied at compile time


• C++ use templates. There is one different class for every specialization, and that class must be defined at compile time. That is the reason why the implementation of templated classes must be in include files, unless you know all the implementations that will be used and declare them at compile time.