las plantillas pueden no ser "virtuales"

Question

Dado el siguiente código, el compilador muestra un mensaje que indica que error: templates may not be ‘virtual’. ¿Alguien tiene alguna sugerencia sobre cómo resolver el error?

template < class FOO_TYPE> 
class CFoo{ 
    public: 
     ... 
     template < class BAR_TYPE > 
     virtual void doSomething(const CBar<BAR_TYPE> &); // here's the error 
     ... 
     virtual ~CFoo(); 
    protected: 
     MyClass <FOO_TYPE> * m_pClass; 
}; 

template < class FOO_TYPE > 
template < class BAR_TYPE > 
void CFoo<FOO_TYPE>::doSomething(const CBar<BAR_TYPE> & refBar){ 
    ... 
} 

Answer 1

La razón más fácil para ver por qué esto es ilegal es considerar el vtable. Claro, eso es solo una implementación común, y otros están permitidos. Pero todas las funciones de virtual en C++ están diseñadas de tal manera que se pueden implementar con un vtable.

Ahora, ¿cuántas entradas hay en el vtable de CFoo<int>? ¿Hay una entrada para doSomething<float>? ¿Y doSomething<float*>? ¿Y doSomething<float**>? Las plantillas como estas permiten generar un conjunto infinito de funciones. Por lo general, eso no es problema, ya que solo se usa un subconjunto finito, pero para las funciones virtuales este subconjunto no se conoce, y por lo tanto, el valor de la tabla debe ser infinito.

Ahora, es posible que realmente quisiera solo una entrada en el vtable. En ese caso, tendría que escribir de la siguiente manera:

template < class FOO_TYPE, class BAR_TYPE> 
class CFoo{ 
    public: 
     ... 
     virtual void doSomething(const CBar<BAR_TYPE> &); // now OK. 
     ... 
     virtual ~CFoo(); 
    protected: 
     MyClass <FOO_TYPE> * m_pClass; 
}; 

Esto significa que la viable para CFoo<int, float> tendrá una entrada, por doSomething(float const&).

Answer 2

Bueno, el mensaje de error es bastante claro. Member function templates can't be virtual. Cómo resolver esto depende de su problema, pero lo más fácil sería hacer que las funciones miembro no sean virtuales y reconsiderar su diseño.

Answer 3

Si realmente necesita hacer que este método sea virtual, considere la posibilidad de hacerpolimórfico y pasar un tipo de base en el que no esté templado.

EDIT: algo como esto:

// non-templated base class 
class BarBase 
{ 
// common methods go here.. 
}; 

template <typename BAR_TYPE> 
class CBar : public BarBase 
{ 
// implement methods from BarBase ... 
}; 

template < class FOO_TYPE> 
class CFoo{ 
    public: 
     ... 
     // now we take the base type, and this method does not need to be a template 
     virtual void doSomething(BarBase const* ptrBar); 
     ... 
     virtual ~CFoo(); 
    protected: 
     MyClass <FOO_TYPE> * m_pClass; 
}; 

template < class FOO_TYPE > 
void CFoo<FOO_TYPE>::doSomething(BarBase const* ptrBar){ 
.. 
} 

Answer 4

Puede utilizar lo que llamamos en Symbian como "patrón de diseño de la plantilla". Aquí hay un código de muestra para que tenga una idea:

class Base { 
public: 
     virtual int DoSomething() = 0; 
protected: 
     Base(); 
}; 

class IntermediateBase : public Base { 
protected: 
     IntermediateBase(void* aSomeParam, void* aArg) 
     : iSomeParam(aSomeParam) 
     , iArgs(aArg) 
     {} 

     virtual int DoSomething() = 0; 
protected: 
     void* iSomeParam; 
     void* iArgs; 
}; 

template <class TYPE, class INPUT> 
class ConcreteClass : public IntermediateBase { 
     typedef int (TYPE::*MemberFuncPtr)(const INPUT&); 
public: 
     ConcreteClass(TYPE& aCommandType, 
         INPUT& aArgumentsToCommand, 
         MemberFuncPtr aMFP) 
     : IntermediateBase(static_cast<TYPE*>(&aCommandType), 
          static_cast<INPUT*>(&aArgumentsToCommand)) 
     , iMFP(aMFP) 
     {} 

     virtual int DoSomething() // VIRTUAL AND INLINE Note - dont make it 
            // virtual and inline in production if 
            // possible to avoid out-of-line copy 
     { 
      return static_cast<TYPE*>(iSomeParam)->*ConcreteClass::iMFP) 
          (*(static_cast<INPUT*>(iArgs)); 
     } 
private: 
     MemberFuncPtr iMFP; 
};