Call right template function via base class pointer

Question

I think I'm already close to the solution but am missing the final step. I want to call a templated member function where I only have a pointer to the base class and the type is already predefined, so should not depend on the actual argument type.

This is what I have:

template <typename T> class TTemplateTest;

class CTemplateTest
{
public :
    CTemplateTest(){};
    template <typename T> double Process(T atValue)
    {
        return static_cast<TTemplateTest<T>* >(this)->Process(atValue);
    }
};
//------------------------------
template <class T>
class TTemplateTest:public CTemplateTest
{
    public :
        TTemplateTest() : CTemplateTest(){};
        virtual double Process(T atNewValue) {return atNewValue;};
};
//------------------------------
template <class T>
class TTemplateTestInt:public TTemplateTest<T>
{
public :
    TTemplateTestInt(){};
    virtual double Process(T atNewValue);
};
//------------------------------
template <class T> double TTemplateTestInt<T>::Process(T atNewValue)
{
    return atNewValue;
}

CTemplateTest* pTTest = new TTemplateTestInt<int>();

// application code
double d = 5.5;
double r;
r = pTTest->Process(d);

I would like to process the argument as integer in this example, no matter what type the argument is. It calls the right function but the value is garbage as the double is interpreted as integer instead of being converted.

I have looked at other questions (and other sites) but couldn't find a match or solution, e.g. calling a template function of a derived class

The solution probably is CRTP but I couldn't figure out how to use it. The application code should stay like this, the classes definitions can change. The reason for this code is that it is generated and used in runtime from some xml configuration file. So the type is not really known at the function call.

It would probably help if I could use the defined type, like:

template <typename T> double Process(T atValue)
{
    return static_cast<TTemplateTest<T>* >(this)->Process((this::type)atValue);
}

Or prevent the automatic creation of the function using double so the argument is converted to integer as it would happen on a non templated function.

Thanks for any help.

Edit: Next solution

Does this look valid? It doesn't need casting and we only need a handful of different basic types for the template so there won't be many redirector functions. And it should still be efficient (without typeinfo and such). I'm also posting it in case somebody else has a similar problem.

class CTemplateTest
{
public :
    CTemplateTest(){};
    virtual inline double Process(double adValue)=0;
    virtual inline double Process(int aiValue)=0;
};
//------------------------------
template <class T>
class TTemplateTest:public CTemplateTest
{
    public :
        TTemplateTest() : CTemplateTest(){};
        virtual inline double Process(double adValue) {
            return ProcessImp((T)adValue);
        }
        virtual inline double Process(int aiValue) {
            return ProcessImpl((T)aiValue);
        }
        virtual double ProcessImpl(T atNewValue)=0;
};
//------------------------------
template <class T>
class CTemplateTestInt:public TTemplateTest<T>
{
public :
    CTemplateTestInt(){};
    virtual double ProcessImpl(T atNewValue) {return atNewValue;};
};

This then gives the desired result with

CTemplateTest* pTTest = new TTemplateTestInt<int>();

// application code
double d = 5.5;
double r;
r = pTTest->Process(d);
// -> r = 5

Thanks

Answer 1

Your code looks fairly confusing, both in terms of naming and the logic. I don't know what you want to do, but I can explain why your code will lead to strange behavior, which also indicates there are some fondamental design flaw in your code.

To be simplified, your code has something similar to this:

class A {};

class B : public A {};

class C : public A {};

int main () {
    A *a_ptr = new B {};
    C *c_ptr = static_cast<C*>(a_ptr);
}

There is no reinterpret_cast, but this code still breaks the type system and will lead to undefined behavior. Because B has nothing to do with C, even if they both derive from A.

Back to your code, in class CTemplateTest, function

template <typename T> double Process(T atValue)
{
    return static_cast<TTemplateTest<T>* >(this)->Process(atValue);
}

will obtain type T by template argument deduction, not from any predefined type. Thus pTTest->Process(d) will deduce type T to be double and in that function, static_cast the this pointer to an irrelevant pointer TTemplateTest<double>*. But this pointer is indeed a TTemplateTest<int>*, these two classes have no relation except both deriving from CTemplateTest. So it's just the simplified case.

I don't know how to fix this code...

Answer 2

A few observations:

1) your base class has no virtual function, but your derived classes each have unique, unrelated virtual functions. They do not override anything so are kind of pointless being virtual.

2) The base class doesn't know what type the derived type was instantiated with. When CTemplateTest::Process is called, that T is the argument deduced for the function call, and is unrelated to the T used for the derived type. You're merely casting the object to the template instantiated with the type you were provided, ignoring the type your object actually is. This accounts for the garbage; it's undefined behavior.

3) There is no such thing as a template virtual function. One or the other; take your pick. That's basically what I think you are trying to simulate. You want the same function to take any type of parameter and have it passed, as that type, to the derived type, who knows how to process it its own templated way. I'm not sure of a satisfying way to accomplish this.

One thought is to pre-determine a fixed set of types you will accept and handle them individually, one virtual function per supported type. You may be able to make this a bit more flexible with a template parameter list and use the compiler to generate the functions, but I haven't thought that approach entirely through. :)