在派生的模板类中从基类重新实现虚函数

Question

I have a base class which has a virtual function :

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

}

and a derived (template) class of 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
}

This compiles. But when I try to instanciate a DerivedClass<ClassB> I get the error :

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

Why do I have this error? Why it does not take Base::myFunction instead of forcing me to implement a generic myFunction in DerivedClass or a specialized function DerivedClass::myFunction ?

Note : the assert in myFunction is because ClassB is not supposed to call myFunction during runtime . For exemple if myFunction is getRadius , DerivedClass<Circle>::getRadius() is okay but DerivedClass<Square>::getRadius() should not be called.

Note 2 : The other topics I found were not clear about this point

Answer 1

Why it does not take Base::myFunction instead of forcing me to implement a generic myFunction in DerivedClass or a specialized function DerivedClass::myFunction ?

You forced that yourself, by the declaration:

void myFunction();

Consider fully specializing the class template, which will generate classes conditionally with or without overriding myFunction , eg:

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
}

---

If there's some common stuff, you can put it in:

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

and then refactor DerivedClass to use single inheritance of this class template.

That's it for your question, but as others were noting, I think you have a bigger, design problem.

Answer 2

Another method to fix the compiler error (not the design error) is to move the definition of myFunction to the derived template:

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

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

and then specialise only the methods you need:

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

Answer 3

The function is already declared for all types. Definition might come from anywhere, including other compilation units. You'll only need the definition when the function is referred - and your virtual function is (implicitly) referred during construction.