reimplementieren eine virtuelle Funktion von der Basisklasse in einer abgeleiteten Klasse Vorlage

Question

I eine Basisklasse haben, die eine virtuelle Funktion hat:

class Base { 
    ... 
    virtual void myFunction() { assert(0 && "not implemented yet"); } 

} 

und eine abgeleitete (Templat) -Klasse der Base:

DerviedClass.hpp :

Template<typename T> 
class DerivedClass : public Base, public T { 

    ... 
    void myFunction(); 

} 

DerivedClass.cpp:

template <> 
void DerivedClass<ClassA>::myFunction() { 
//Something ClassA is suppose to do 
} 

Dies wird kompiliert. Aber wenn ich versuche, eine DerivedClass<ClassB> zu instanziieren bekomme ich den Fehler:

IProject.o:-1: erreur : undefined reference to `DerivedClass<ClassB>::myFunction()' 

Warum habe ich diesen Fehler? Warum dauert es nicht Base::myFunction statt mich zu zwingen, eine generische myFunction in DerivedClass oder eine spezialisierte Funktion DerivedClass::myFunction zu implementieren?

Hinweis: die Assertion in myFunction ist, weil ClassB nicht myFunction während runtime anrufen soll. Zum Beispiel wenn myFunction ist getRadius, DerivedClass<Circle>::getRadius() ist in Ordnung, aber DerivedClass<Square>::getRadius() sollte nicht aufgerufen werden.

Anmerkung 2: Die anderen Themen, die ich waren zu diesem Zeitpunkt nicht klar gefunden

Answer 1

Warum es nicht Base::myFunction nimmt statt mich zu zwingen, eine generische myFunction in DerivedClass oder eine spezialisierte Funktion DerivedClass::myFunction zu implementieren?

Sie gezwungen, dass sich durch die Erklärung:

void myFunction(); 

Betrachten voll spezialisiert die Klassenvorlage, die Klassen bedingt mit oder ohne zwingende myFunction generieren, zB:

template <typename T> 
class DerivedClass : public Base, public T { 
    // not overriding  
}; 

template <> 
class DerivedClass<ClassA> : public Base, public ClassA { 
    void myFunction() override; 
}; 

template <> 
void DerivedClass<ClassA>::myFunction() { 
    // something ClassA is supposed to do 
} 

---

Wenn es einige gemeinsame Sachen gibt, können Sie es einfügen:

template <typename T> 
class DerivedClassCommons : public Base, public T { 
    // common stuff 
}; 

und dann refactor DerivedClass um die einfache Vererbung dieser Klassenvorlage zu verwenden.

Das ist es für Ihre Frage, aber wie andere bemerkten, denke ich, dass Sie ein größeres, Design-Problem haben.

Answer 2

Die Funktion ist bereits für alle Typen deklariert. Die Definition könnte von überall her kommen, einschließlich anderer Kompilierungseinheiten. Sie benötigen die Definition nur, wenn die Funktion referenziert wird - und Ihre virtuelle Funktion wird (implizit) während der Konstruktion referenziert.

Answer 3

Eine andere Methode, um die Compiler-Fehler (nicht die Design Fehler) zu beheben, ist die Definition von myFunction der abgeleiteten Vorlage zu bewegen:

class Base { 
    virtual void myFunction() = 0; 
} 

template<typename T> 
class DerivedClass : public Base, public T { 
    void myFunction() { 
     throw "not implemented, go away"; 
    } 
} 

und dann spezialisieren nur die Methoden, die Sie brauchen:

template <> 
void DerivedClass<ClassA>::myFunction() { 
//Something ClassA is suppose to do 
}