szablony mogą nie być "wirtualne"

Question

Zgodnie z poniższym kodem kompilator wyświetla komunikat wskazujący, że error: templates may not be ‘virtual’. Czy ktoś ma sugestię, jak rozwiązać problem?

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

Najprostszym powodem, dlaczego jest to nielegalne jest rozważając vtable. Oczywiście, to tylko jedna powszechna implementacja, a inne są dozwolone. Ale wszystkie funkcje w C++ są zaprojektowane tak, że mogą być implementowane za pomocą vtable.

Teraz, ile wpisów jest w vtable z CFoo<int>? Czy istnieje wpis dotyczący doSomething<float>? I doSomething<float*>? I doSomething<float**>? Szablony takie jak te pozwalają na generowanie nieskończonego zestawu funkcji. Zwykle nie stanowi to problemu, ponieważ używasz tylko skończonego podzbioru, ale dla funkcji wirtualnych ten podzbiór nie jest znany, dlatego też vtable musiałby być nieskończony.

Możliwe, że naprawdę chciałeś tylko jednego wpisu w vtable. W takim przypadku, można by napisać to w następujący sposób:

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

Oznacza to, że vtable dla CFoo<int, float> będzie miał jeden wpis, na doSomething(float const&).

Answer 2

Cóż, komunikat o błędzie jest całkiem jasny. Member function templates can't be virtual. Sposób rozwiązania tego problemu zależy od twojego problemu, ale najprościej byłoby uczynić funkcje użytkownika nie-wirtualnymi i ponownie rozważyć twój projekt.

Answer 3

Jeśli naprawdę chcesz, aby ta metoda była wirtualna, rozważ polimorficzne polimorficzne przekształcenie i przekazanie typu podstawowego, który nie jest szablonem.

EDIT: coś takiego:

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

Można wykorzystać to, co nazywamy w Symbiana jako „wzorzec projektowania szablonu”. Oto przykładowy kod, aby dać Ci pomysł:

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