C ++中的虚函数和继承

Question

The code segment below works fine:

#include <iostream> 
#include <string>

using namespace std;

class HelpInterface {
public:
    void getHelp();
};

class Applicaiton : public HelpInterface {
public:
    void getHelp() {
        cout << "General help";
    }
};

int main(void) {
    Applicaiton applicaiton;
    applicaiton.getHelp();
}

Make the getHelp function virtual in HelpInterface class and I will get a linker error:

class HelpInterface {
public:
    virtual void getHelp();
};

If I make an empty implemenation of getHelp as below things will work again:

class HelpInterface {
public:
    virtual void getHelp() {};
};

Can someone please help me understand why virtual throws a linker error unless I have an implementation for getHelp in the base class and why a non-virtual function with no implementation works just fine? In this example, the base function never gets called.

Here is a screenshot of VS2013 with the linker error:

Answer 1

If you want your base class method to be virtual and provide no implementation, you must set it equal to zero like this:

class HelpInterface {
public:
    virtual void getHelp() = 0;
};

This is known as a pure virtual method. It has the effect of making your class abstract and forcing all of its derived classes to provide an implementation of the method. Consequently, take note that you will no longer be able to create an instance of the base class because it is abstract.

Answer 2

When a method is in the base class but isn't virtual the linker will not actually reference the implementation of the method if you don't have an explicit call to that method on either a pointer/reference to the base type (On an instance of the derived class) or an instance of the base type.

Virtual functions can be implemented a number of different ways, and are implementation specific. One of the most common is by using a virtual table. (Also known by virtual method table, virtual function table, virtual call table, dispatch table, vtable, or vftable), and I'm pretty sure your compiler (VS2013) uses this method of implementing virtual functions.

A virtual table is a table of function pointers for the virtual member functions. The class instance would contain a pointer to the table that the class belongs to.

When you make a function virtual the linker tries to put it into the virtual table for that type. It doesn't matter whether you call it or not or instantiate a base class (also an implementation specific detail).

As qexyn has already answered, to get around that you declare the method as pure virtual by adding = 0 after the virtual function declaration. This tells the linker to put a null pointer in the virtual function table for the class. You can also declare the virtual function pure virtual and also provide an implementation. This forces the derived classes to implement that function, but allows them to choose to use the default method.

Answer 3

The reason for this is that your base class definition is using indirection to get the actual function for Application .

This is often implemented with a function pointer, but in any case there could be a derived class that doesn't override the base class implementation.

Although this isn't usually reproducible that is simply because member functions are implicitly declared inline and when the implementation is visible an optimizing compiler will do exactly that; inline the function. The proof is in the optimization.

What you want, is to make sure that every derived class from your base implements getHelp() . This is a common idiom and is a core language feature. You want a "pure virtual function". This will make your base class an "abstract base class" which is actually a synonym for "interface" in object-oriented jibber-jabber.

The way to do this in C++ is with a special member-function specific syntax after all of the member function qualifiers (I'm using trailing return types here cause I think they're pretty):

class base{
    public:
        virtual auto func() -> void = 0;
};

This specifies that base is an abstract base class with a pure virtual function func() that all classes derived from it will implement.

In your case you would write:

class HelperInterface{
    public:
        virtual void getHelp() = 0; // probably want const qualifier
};

And just leave Application as it is.

You learn something every day, huh?