C ++继承，模板和覆盖

Question

I'm having some trouble formalizing an interface to a template class. Why does the following compile?

class IFoo {
public:
    virtual void functionA()=0;
};

template<class T>
class Foo : public IFoo{
public:
    void functionA() override { };
    void functionB() override { };
};

functionB obviously does not exist in IFoo, so why is the compiler not throwing an error? Currently running on GCC 5.4.

A bit of background as to how I came to this issue: I'm putting together some code for a side project of mine which depends heavily on common linear algebra routines. I want to abstract over the choice of library in order to eg facilitate benchmarking. The idea is to use an interface like IFoo to do this, so that the business logic code only knows about IFoo rather than have to accomodate the quirks of any single linear algebra lib. This is feasible because there are only a handful of key functions that are necessary; I'm not looking to provide an interface for all available operations. I need the templates to allow for processing using different degrees of precision, eg float, double, minifloats, etc. to be handled by the same subclass.

In my head a sensible design for this problem is re-wrapping access to these libs with this interface in separate compilation units to produce independent static or runtime libraries that implement this interface. Switcing from one lib to another would then be as simple as linking against the desired library; no changes in code are necessary. Any thoughts on this general strategy also appreciated!

Answer 1

Templates are instantiated only if some other code uses them. Your example doesn't have that code so it really doesn't matter whether this compiles or not. Try creating an object of Foo<int> and see for yourself that GCC will then complain.

Answer 2

You only defined a class template but you did not instantiate it. Excerpt from the template reference :

A class template by itself is not a type, or an object, or any other entity. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated:

If you tried to instantiate an object with:

int main() {
    std::unique_ptr<IFoo> p = std::make_unique<Foo<void>>();
}

then GCC would complain with:

error: 'void Foo::functionB() [with T = void]' marked 'override', but does not override
void functionB() override { };

Live example on Coliru
While the above compiles on VS if you tried to call a member function with:

p->functionB();

you would receive the following errors:

'functionB' : is not a member of 'IFoo'
class "IFoo" has no member "functionB"

That being said it is unclear where in your class you are actually using the template. If you removed the template<class T> you would get the errors you expected in the first place.