Virtual template design question.

[REDDemon]

Does anyone have any elegant solution for solving a problem?


I have a Templated class. by default I use this class with different types (float, double, integer etc.). Now I wan't to give that class different implementations (one for single core execution and 1 for multithreading).

This is not possible in C++ to have virtual template methods. So some possible solutions are

1) write a different interface for every type and then write 2 implementation for each interface. (this requires of adding new methods for exchanging values between the two classes)

2) just add a branch to very method in the old implementation

Code: Select all

//so:
T getValue()
{
    if(multythreadin)
    {
    //new code
        return Value; //of type T
    }
    //old code
        return Value;
}

I still need to return references/pointers to the class or to the value so this solutions is not possible for me:
http://www.java2s.com/Tutorial/Cpp/0260 ... mplate.htm

[serengeor]

both ways could do the job I think, you could also use:

Code: Select all

T getValue() 
{ 
    #ifdef MUTLITHREADIN
     
    //new code 
        return Value; //of type T 
    #else 
    //old code 
        return Value;
    #endif
}

which should decrease compilation size? though might not be usable if it has selective multithreading

[CuteAlien]

Not sure if it's a good idea in this case - but you can do virtual functions with templates which don't use the virtual function mechanism at all, but instead work by passing the derived class as a template parameter.

It's called using the "Curiously recurring template pattern" (http://en.wikipedia.org/wiki/Curiously_ ... te_pattern)

For example:

Code: Select all

#include <iostream> 

template <typename T>
struct Base
{
	void doFoo()
	{
		static_cast<T*>(this)->foo();
	}
};

struct SingleCore : public Base<SingleCore>
{
	void foo()	
	{
		 std::cout << "single core" << std::endl;
	}
};

struct MultiCore : public Base<MultiCore>
{
	void foo()	
	{
		 std::cout << "multi core" << std::endl;
	}
};

int main()
{
	SingleCore sc;
	MultiCore mc;

	sc.doFoo();
	mc.doFoo();

	return 0;
}

[hybrid]

Question that is still unclear to me is whether you want to choose between the implementations during run-time or at compile-time?! You can also pass parameters to use one or the other, and also via templates. This would give something in between your solution 2) and serengeor's.

[REDDemon]

I want to do that at runtime. Thanks for suggestions. This wikipedia page was very interesting. Now i found my way