[solved] Template virtual function in C++

Question

I know this isn't legal C++ due to the compiler not being able to determine how big exactly the vtable is. I'm looking for alternatives.
Basically, I have an abstract base class defining the interface for a set of derived classes. One of the functions being exposed through this interface is called run(). Each derived class does something different with run(). So it looks something like this:-
class base {
protected:
base() { }
public:
virtual void run(...) = 0;
/* rest of api here */
class derived : public base {
private:
template<class T>
void runTemplate() {
/* Do something with data-type T */
public:
void run(...) {
switch(some_int_value_from_the_input) {
case 1:
runTemplate<char>();
break;
case 2:
runTemplate<short>();
break;
case 3:
runTemplate<int>();
break;
default:
/* throw error */
My 'problem' is that every single derived class has exactly the same run() function, they only differ in the algorithm within runTemplate(). However, since I'm not allowed to implement run() in base calling a templated virtual function in base, I seem forced to have the code above, which seems to me to unnecessarily duplicate code.
Is there another way to implement the above? My objective is to keep the amount of coding done in the derived class to the bare minimum (pretty much just the algorithm if possible), hence why I'm trying to move run()'s definition from derived to base.
Last edited by ngoonee (2009-10-07 14:11:01)

Answer 1

scio wrote:
Sorry I typing to you and talking to someone else... I meant polymorphism.
However, I'm not sure if I understand your end goal.  It seems like templates are not needed, but there might be a reason in your code:
class base {
protected:
base() { }
public:
virtual void run(...) = 0;
/* rest of api here */
class algowrapper{
public:
algowrapper(...) {
/* Use arg to setup algorithm /*
static void processInput(...) {
/* Do something with input and defined algorithm */
class runner : public base{
protected:
runner():algo(NULL) { }
algowrapper* algo;
public:
virtual void run(...) {
if (algo)
algo->processInput();
class derived : public runner{
public:
derived(...):runner(),algo(new algowrapper(/* some algorithm */)) { }
class derived2 : public runner{
public:
derived(...):runner(),algo(new algowrapper(/* different algorithm */)) { }
Hmmm, looks like my explaining skills leave a lot to be desired. Basically I want the separate algorithms to be fully implemented within the derived classes.
Usage case is that, for example, I distribute my executable which includes the object file for base. One of the things my executable does is load .so files (using dlopen), which will be compiled separately from the main executable. These .so files return a pointer to base, but different .so files implement different algorithms. So I can only access the functions which belong to base, since all I have is a pointer to base and no knowledge of the specific derived class, and i just call base->run(...) which is implemented in each derived class and it should handle the rest.
The problem, as I see it, is that runtemplate() shouldn't need to be part of the API in base, yet if it doesn't exist in base, run() cannot call it. Even if it exists in base, it cannot have the form of a template since this is illegal in C++.