C ++ Multiple Language Inheritance and Pure Virtual Functions
Consider the following architecture:
class A //abstract interface
{
public:
virtual void f() = 0;
};
class AA : public A //abstract interface
{
public:
virtual void g() = 0;
};
class AAA : public AA //abstract interface
{
public:
virtual void h() = 0;
};
class B : public A // implementation class
{
public:
void f() override {};
};
class BB : public B, public AA {}; // implementation class
{
public:
void g() override {};
};
class BBB : public BB, public AAA {}; // implementation class
{
public:
void h() override {};
};
Thus, BB
u BBB
are virtual classes, since f is not overridden by BB, and neither f nor g are BBB. My desire is to be able to create BB and BBB (so BB and BBB use the f override defined by B and BBB use the g override defined by BB).
The question is , which inheritance relationship should be marked virtual
for both instantiation BB
and BBB
?
The inheritance diagram should look like this:
A
|\
| \
| \
AA B
| \ |
| \ |
AAA BB
\ |
\ |
BBB
The idea behind this design is that A, AA and AAA are interfaces describing incremental feature levels. B, BB and BB are one corresponding incremental implementation. (So BB, for example, defines whatever AA is required, and also shows what's in B)
source to share
if A AA AAA
are really only interfaces, I mean they don't have any members, then you don't need inheritance virtaul
, only implement interfaces and call them from base classes. What you have implemented in B for interface A must also be implemented in BB and then call B:pureVirtual()
in BB
. Otherwise it should be so; (Then you should look at: 'class1': inherits 'class2 :: member' via dominance )
class A
{
public:
virtual void f() = 0;
};
class AA : virtual public A
{
public:
virtual void g() = 0;
};
class AAA : virtual public AA
{
public:
virtual void h() = 0;
};
class B : virtual public A
{
public:
void f() override { }
};
class BB : public B, virtual public AA
{
public:
void g() override { }
};
class BBB : public BB, public AAA
{
public:
void h() override { }
};
Edit: (No virtual inheritance)
class A //abstract interface
{
public:
virtual void f() = 0;
};
class AA : public A //abstract interface
{
public:
virtual void g() = 0;
};
class AAA : public AA //abstract interface
{
public:
virtual void h() = 0;
};
class B : public A // implementation class
{
public:
void f() override {}
};
class BB : public B, public AA // implementation class
{
public:
void g() override {}
void f() override { B::f(); }
};
class BBB : public BB, public AAA // implementation class
{
public:
void h() override {}
void g() override { BB::g(); }
void f() override { BB::f(); }
};
source to share