Inherit from multiple partial implementations of an abstract base class?

Question

Is it possible to have a number of partial implementations of an abstract interface, and then collect these partial implementations into a single concrete class by using multiple inheritence?

I have the following example code:

#include <iostream>

struct Base
{
    virtual void F1() = 0;
    virtual void F2() = 0;
};

struct D1 : Base
{
    void F1() override { std::cout << __func__ << std::endl; }
};

struct D2 : Base
{
    void F2() override { std::cout << __func__ << std::endl; }
};

// collection of the two partial implementations to form the concrete implementation
struct Deriv : D1, D2
{
    using D1::F1; // I added these using clauses when it first didn't compile - they don't help
    using D2::F2;
};

int main()
{
    Deriv d;
    return 0;
}

This fails to compile with the following errors:

main.cpp: In function ‘int main()’:
main.cpp:27:11: error: cannot declare variable ‘d’ to be of abstract type ‘Deriv’
main.cpp:19:8: note:   because the following virtual functions are pure within ‘Deriv’:
main.cpp:5:18: note:    virtual void Base::F1()
main.cpp:6:18: note:    virtual void Base::F2()

"_abstract interface_" in general: abstract interface implies virtual inheritance (special cases can differ) — curiousguy, Jul 26 '12 at 06:16
"`struct D1 : Base `" Is there a reason why you are using public inheritance here? Is the use of `D1` of interest for client code? — curiousguy, Jul 26 '12 at 20:53
@curiousguy no reason - just whipped up the example - in my particular use I use a mix of both public and private, depending on the situation — Steve Lorimer, Jul 26 '12 at 23:16

juanchopanza · Accepted Answer · 2012-07-26T05:40:55.900

10

Try inheriting virtually from Base:

struct D1 : virtual Base
{
    void F1() override { std::cout << __func__ << std::endl; }
};

struct D2 : virtual Base
{
    void F2() override { std::cout << __func__ << std::endl; }
};

Without the virtual inheritance, your multiple inheritance scenario looks like inheritance from two separate and incomplete base classes D1 and D2, neither of which can be instantiated.

edited Jul 26 '12 at 05:40

answered Jul 26 '12 at 05:31

juanchopanza

223,364
34
402
480

"_incomplete base classes_" **abstract** base classes? – curiousguy Jul 26 '12 at 06:00
@curiousguy not necessarily abstract, just with at least one unimplemented method. – juanchopanza Jul 26 '12 at 06:12
@juanchopanza What is an abstract class? – curiousguy Jul 26 '12 at 06:14
@curiousguy Aha! I get your meaning. I still struggle to think of a class with a bunch if implemented methods as "abstract", but I should respect the C++ jargon. – juanchopanza Jul 26 '12 at 07:21
It is "abstract" because it is not concrete. **Concrete class can have instances, abstract classes cannot**, as simple as that. Have you ever seen an abstract class without any "implemented method"? – curiousguy Jul 26 '12 at 20:16
@curiousguy Of course I have seen abstract classes without any implemented methods. – juanchopanza Jul 26 '12 at 20:35
@curiousguy You either don't know what "without any" means or you don't know what you are talking about. – juanchopanza Jul 26 '12 at 21:30
1

@curiousguy in that case, I take it all back. – juanchopanza Jul 27 '12 at 07:20

curiousguy · Answer 2 · 2012-07-26T07:50:46.587

Is it possible to have a number of partial implementations of an abstract interface, and then collect these partial implementations into a single concrete class by using multiple inheritence?

Yes.

Each Base base class subobject brings two pure virtual functions. How many of those base subobjects do you want in Deriv?

If you want 2 Base base class subobject, Deriv::D1::Base and Deriv::D2::Base (so conversions from Deriv& to Base& would be ambiguous) then you will have 4 different virtual functions in Deriv: Deriv::D1::Base::F1(), Deriv::D1::Base::F2(), Deriv::D2::Base::F1(), Deriv::D2::Base::F2(). Only the first and last ones are implemented, so the two middle ones are pure virtual: Deriv::D1::Base::F2(), Deriv::D2::Base::F1(). You have two entirely independent inheritance relations: Deriv inherits from D1 and Deriv inherits from D2.
If you want only one Base base class subobject Deriv::Base, then you will have only 2 different virtual functions in Deriv: Base::F1(), Base::F2().

Non-virtual inheritance in C++ is "concrete" inheritance, like containment: struct D : B means that for each D object there is exactly one B base class subobject, just like struct C { M m; } means that for each C there is exactly one M class member subobject. These relations are one-to-one.

OTOH, virtual inheritance is a more "abstract": struct D : virtual B means that for each D object is associated with a B base class subobject, but this relation is many-to-one, like struct C { M &m; }.

In general, for any derived class D (here Deriv), and for any virtual base B of D (here Base), all the base classes of D virtually derived from B (here Deriv::D1, Deriv::D2) contribute to the overriding of the virtual functions in the base class:

Base::F1() is overridden by Deriv::D1::F1()
Base::F2() is overridden by Deriv::D2::F2()

Non-virtual and virtual inheritance are very different inheritance relations, just like if non-virtual member functions and a virtual function introduce different relations between functions with the same signature in derived and base classes (hiding vs. overriding).

Like virtual and non-virtual functions, virtual and non-virtual base classes must be used in different situations (and one is not "better" than the other in general).

How to "fix" your code without virtual inheritance?

struct Deriv : D1, D2
{
    using D1::F1; // I added these using clauses when it first didn't compile - they don't help
    using D2::F2;
};

Yes: using declaration control name-lookup, so they affect visibility and ambiguity issues, not virtual functions overriding.

With your original non-virtual inheritance based design, in order to make Deriv a concrete class, you would have to explicitly implement both F1() and F2() virtual function signatures (there are 4 virtual functions in Deriv, but with only 2 different signatures), so you need 2 function definitions:

struct Deriv : D1, D2
{
    void F1() override { D1::F1(); }
    void F2() override { D2::F2(); }
};

Note that Deriv::F1() overrides Deriv::D1::F1() and Deriv::D2::F1().

Inherit from multiple partial implementations of an abstract base class?

2 Answers2

How to "fix" your code without virtual inheritance?

Linked