How to use in multiple inheritance an abstract method

Question

It looks like that there is something that I don't understand about multiple inheritance and abstract methods. I am implementing some hardware functionality in SystemC, with multiple target HWs. I have two different levels of software implementation. The first one is optimized for performance; the second one on its top, has some display, etc. functionality. [Note, in the hardware world "top" refers to the highest level instance which is usually a wrapper or a testbench for the hardware instance]

To actually handle a HW, in scSW I implemented "Hold()". When I want to use it in the higher level (see SW and SW2), my compiler said

error: ‘scHW’ is an ambiguous base of ‘SW’
 struct SW : scSW, HW { virtual bool Holds(){return scHW::Holds();} };

and

invalid new-expression of abstract class type ‘SW2’
     SW2* S2 = new SW2;
                   ^~~
because the following virtual functions are pure within ‘SW2’:
 struct SW2 : scSW, HW {  };

It also added:

 request for member ‘Holds’ is ambiguous
     std::cerr << S2->Holds();

I especially do not see, how can a method be pure and ambiguous, at the same time? What do I wrong and what is the correct way of coding what I want?

#include <iostream>
struct Virtual { virtual bool Holds() = 0;};
struct scHW { bool Holds(){return true;}};
struct scSW : scHW, Virtual {};
struct HW : scHW { };
struct HW2 : scHW { virtual bool Holds(){return scHW::Holds();}};
struct SW : scSW, HW { virtual bool Holds(){return scHW::Holds();} };
struct SW2 : scSW, HW {  };

int main()
{
    HW* H = new HW;
    HW2* H2 = new HW2;
    scHW* H1 = new scHW;
    SW* S = new SW;
    SW2* S2 = new SW2;
    std::cerr << S->Holds();
    std::cerr << H->Holds();
    std::cerr << H2->Holds();
    std::cerr << S2->Holds();
}

Hmm, this may be more complicated than typical diamond problem — Yksisarvinen, Feb 04 '19 at 11:31
As a side note, `Holds`'s name suggests it is a getter in general, so you might consider declaring it `const`. — bipll, Feb 04 '19 at 11:32
Also see [How can I avoid the Diamond of Death when using multiple inheritance?](https://stackoverflow.com/q/137282/608639) — jww, Feb 04 '19 at 11:33
Tip: don't use variable/type names that differ from language/library names only in case e.g., `Virtual`. — Paul Floyd, Feb 04 '19 at 11:33
@Yksisarvinen When not using virtual inheritance, it isn't called a diamond — curiousguy, Feb 06 '19 at 20:12

score 1 · Answer 1 · answered Feb 04 '19 at 11:31

It's pure and ambiguous at the same time because name lookup and virtual function overriding are mostly orthogonal mechanisms. You see here:

struct scSW : scHW, Virtual {};
struct HW : scHW { };

Looking up Holds in scSW will go into two different base class sub-object (as explained on your previous question). The scHW and Virtual bases. As such, the lookup is ambiguous. Those are two different functions in two different classes that are referred to by the same identifier.

Which not quite so coincidentally is also why Virtual::Holds is not overridden in scSW. The member from scHW is unrelated. There is no virtual function overrider in scSW, so that class remains abstract.

score 0 · Answer 2 · answered Feb 04 '19 at 11:34

0

Looks like you might not want multiple inheritance, and just do:

 struct scHW : Virtual { virtual bool Holds(){return true;}};
 struct scSW : scHW {};
 ...

that way scHW isn't abstract and can be instantiated.

answered Feb 04 '19 at 11:34

Paul Evans

27,315
3
37
54

I definitely want multiple inheritance: Virtual provides the abstract handling, and scSW the physical one. The abstract function enables other methods of scSW to implement handling a concrete HW without knowing the details of the hardware, in this case different hardware units. In the way you proposed, Virtual provides a 'default' method, and the programmer of the hardware driver is not forced to implement (override) the method. – katang Feb 04 '19 at 12:25

How to use in multiple inheritance an abstract method

2 Answers2