non possono essere 'virtuali'

Question

Dato il codice sotto, il compilatore mostra un messaggio che indica che error: templates may not be ‘virtual’. Qualcuno ha un suggerimento su come risolvere il bug?

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

Il motivo più semplice per capire perché questo è illegale è considerando il vtable. Certo, questa è solo un'implementazione comune, e altri sono consentiti. Ma tutte le funzioni virtual in C++ sono progettate in modo tale che possano essere implementate con un vtable.

Ora, quante voci ci sono nello vtable di CFoo<int>? C'è una voce per doSomething<float>? E doSomething<float*>? E doSomething<float**>? Modelli come questi consentono di generare un insieme infinito di funzioni. Di solito non è un problema, poiché si usa solo un sottoinsieme finito, ma per le funzioni virtuali questo sottoinsieme non è noto, e quindi il vtable dovrebbe essere infinito.

Ora, è possibile che tu volessi davvero solo una singola voce nel vtable. In tal caso, ci si scrive come segue:

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; 
}; 

Ciò significa che il vtable per CFoo<int, float> avrà una voce, per doSomething(float const&).

Answer 2

Bene, il messaggio di errore è abbastanza chiaro. Member function templates can't be virtual. Come risolvere questo dipende dal tuo problema, ma la cosa più semplice da fare sarebbe rendere le funzioni membro non virtuali e riconsiderare il tuo design.

Answer 3

Se è davvero necessario rendere questo metodo virtuale, prendere in considerazione la realizzazione di CBar<> polimorfico e passare un tipo di base in cui non è presente un modello.

EDIT: qualcosa di simile:

// 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

È possibile utilizzare ciò che noi chiamiamo in Symbian come "design pattern modello". Ecco un esempio di codice per darti un'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; 
};