C++ 纯虚函数的多重继承问题

Question

I have produced a minimal example to replicate the problem I am seeing with a more complex class hierarchy structure:

#include <string>
#include <iostream>


class A
{
protected:

    virtual
    ~A() = 0;

};

inline
A::~A() {}

class B : public A
{
public:

    virtual
    ~B()
    {
    }

    std::string B_str;
};

class BB : public A
{
public:

    virtual
    ~BB()
    {
    }

    std::string BB_str;
};

class C : public A
{
protected:

    virtual
    ~C()
    {
    }

    virtual
    void Print() const = 0;
};

class D : public B, public BB, public C
{
public:

    virtual
    ~D()
    {
    }
};

class E : public C
{
public:

    void Print() const
    {
        std::cout << "E" << std::endl;
    }
};

class F : public E, public D
{
public:

    void Print_Different() const
    {
        std::cout << "Different to E" << std::endl;
    }

};


int main()
{

    F f_inst;

    return 0;
}

Compiling with g++ --std=c++11 main.cpp produces the error:

error: cannot declare variable ‘f_inst’ to be of abstract type ‘F’

    F f_inst;

note:   because the following virtual functions are pure within ‘F’:

    class F : public E, public D
          ^
note:   virtual void C::Print() const

    void Print() const = 0;
         ^

So the compiler thinks that Print() is pure virtual.

But, I have specified what Print() should be in class E .

So, I've misunderstood some of the rules of inheritance.

What is my misunderstanding, and how can I correct this problem?

Note: It will compile if I remove the inheritance : public D from class F .

Answer 1

Currently your F is derived from C in two different ways. This means that an F object has two separate C bases, and so there are two instances of C::Print() .

You only override the one coming via E currently.

To solve this you must take one of the following options:

• Also override the one coming via D , either by implementing D::Print() or F::Print()
• Make Print non-pure
• Use virtual inheritance so that there is only a single C base.

For the latter option, the syntax adjustments would be:

class E : virtual public C

and

class D : public B, public BB, virtual public C

This means that D and E will both have the same C instance as their parent, and so the override E::Print() overrides the function for all classes 'downstream' of that C .

For more information , look up "diamond inheritance problem". See also Multiple inheritance FAQ