![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/cd1.png\")
<\/a><\/figure>\n\n\n\nThis is a simple hierarchy with the following classes:<\/p>\n\n\n\n
control<\/code> is the base class of all visual elements and has some data members such asid<\/code>,width<\/code>, andheight<\/code><\/li>image<\/code> andbutton<\/code> are classes derived from control, each with its own additional data members<\/li>image_button<\/code> that is both an image and a button and inherits from these two classes, also with its own additional data members<\/li><\/ul>\n\n\n\nThis can be represented in code as follows:<\/p>\n\n\n\n
struct control\n{\n int id;\n int width;\n int height;\n};\n\nstruct image : public control\n{\n int stretch_style;\n int stretch_direction;\n};\n\nstruct button : public control\n{\n int text_alignment;\n};\n\nstruct image_button : public image, public button\n{\n int content_alignment;\n};<\/pre>\n\n\n\nThe image above shows the inheritance hierarchy, but the object memory layout is different. This actually looks like this:<\/p>\n\n\n\n
![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/layout1.png\")
<\/a>Object memory layout<\/em><\/figcaption><\/figure>\n\n\n\n What we can see from here is that:<\/p>\n\n\n\n
image<\/code> contains everything thatcontrol<\/code> has plus its own data members<\/li>button<\/code> contains everything thatcontrol<\/code> has plus its own data members<\/li>image_button<\/code> contains everything thatimage<\/code> andbutton<\/code> has plus its own data members; however, this implies it has two copies of the data members ofcontrol<\/code>.<\/li><\/ul>\n\n\n\nAs a result, trying to access any of the data members from
control<\/code> using animage_button<\/code> object results in a compiler error.<\/p>\n\n\n\nimage i;\ni.id = 1; \/\/ OK\n\nbutton b;\nb.id = 2; \/\/ OK\n\nimage_button ib;\nib.id = 3; \/\/ error<\/pre>\n\n\n\n
error C2385: ambiguous access of 'id'\nmessage : could be the 'id' in base 'control'\nmessage : could be the 'id' in base 'control'<\/pre>\n\n\n\n
In this example, we only had data members but the same problem occurs with member functions.<\/p>\n\n\n\n
\n\n\n![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/cd2.png\")
<\/a><\/figure>\n\n\n\nA slightly modified version of the class hierarchy with a virtual function
draw()<\/code> overridden in each class, and a member functionresize()<\/code> in thecontrol<\/code> base class.<\/p>\n<\/div>\n\n\n\n\n![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/layout2.png\")
<\/a><\/figure>\n\n\n\nMemory layout now contains additional a pointer to a virtual table.<\/p>\n<\/div>\n<\/div>\n<\/div><\/div>\n\n\n\n
struct control\n{\n int id;\n int width;\n int height;\n\n void resize(int const w, int const h, bool const redraw = true) \n {\n width = w;\n height = h;\n if(redraw)\n draw();\n }\n\n virtual void draw() \n { \n std::cout << \"control::draw\\n\"; \n }\n};\n\nstruct image : public control\n{\n int stretch_style;\n int stretch_direction;\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"image::draw\\n\"; \n }\n};\n\nstruct button : public control\n{\n int text_alignment;\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"button::draw\\n\"; \n }\n};\n\nstruct image_button : public image, public button\n{\n int content_alignment;\n\n virtual void draw() override\n {\n button::draw();\n image::draw();\n std::cout << \"image_button::draw\\n\";\n }\n};\n\nint main()\n{\n image i;\n i.id = 1; \/\/ OK\n i.resize(32, 32); \/\/ OK\n\n button b;\n b.id = 2; \/\/ OK\n b.resize(100, 20); \/\/ OK\n\n image_button ib;\n ib.id = 3; \/\/ error\n ib.resize(100, 20); \/\/ error\n}<\/pre>\n\n\n\nThe solution<\/h2>\n\n\n\n
Here is where virtual inheritance comes to rescue. By declaring a base class as
virtual<\/code> you are ensuring that the memory layout does not duplicate the base class members.<\/p>\n\n\n\nstruct control\n{\n int id;\n int width;\n int height;\n};\n\nstruct image : virtual public control\n{\n int stretch_style;\n int stretch_direction;\n};\n\nstruct button : virtual public control\n{\n int text_alignment;\n};\n\nstruct image_button : public image, public button\n{\n int content_alignment;\n};<\/pre>\n\n\n\nNote<\/strong>: the
virtual<\/code> keyword can be use either before or after the access specifier. Thereforevirtual public control<\/code> andpublic virtual control<\/code> are equivalent.<\/p>\n\n\n\nThe memory layout of the image_button class looks as follows:<\/p>\n\n\n\n
![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/layout3.png\")
<\/a><\/figure>\n\n\n\nFrom this representation, we can see that:<\/p>\n\n\n\n
- there is no duplication of the data members from the
control<\/code> base class<\/li>- the data members from the
control<\/code> class are present at the end of the layout<\/li>- there is a pointer to a virtual base table for both the
image<\/code> andbutton<\/code> classes<\/li><\/ul>\n\n\n\nWith virtual functions added to these classes, the memory layout will also contain a pointer to the virtual function table in the
control<\/code> base class.<\/p>\n\n\n\nstruct control\n{\n int id;\n int width;\n int height;\n\n void resize(int const w, int const h, bool const redraw = true) \n {\n width = w;\n height = h;\n if(redraw)\n draw();\n }\n\n virtual void draw() \n { \n std::cout << \"control::draw\\n\"; \n }\n};\n\nstruct image : virtual public control\n{\n int stretch_style;\n int stretch_direction;\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"image::draw\\n\"; \n }\n};\n\nstruct button : virtual public control\n{\n int text_alignment;\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"button::draw\\n\"; \n }\n};\n\nstruct image_button : public image, public button\n{\n int content_alignment;\n\n virtual void draw() override\n {\n button::draw();\n image::draw();\n std::cout << \"image_button::draw\\n\";\n }\n};<\/pre>\n\n\n\n![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/layout4-1.png\")
<\/a><\/figure>\n\n\n\nHowever, now we can write the following snippet without getting any more errors:<\/p>\n\n\n\n
int main()\n{\n image i;\n i.id = 1; \/\/ OK\n i.resize(32, 32); \/\/ OK\n\n button b;\n b.id = 2; \/\/ OK\n b.resize(100, 20); \/\/ OK\n\n image_button ib;\n ib.id = 3; \/\/ OK\n ib.resize(100, 20); \/\/ OK\n}<\/pre>\n\n\n\nConstruction and destruction of objects<\/h2>\n\n\n\n
When we have a virtual hierarchy, constructors and destructors are invoked as follows:<\/p>\n\n\n\n
- virtual base classes are constructed before non-virtual base classes; therefore, their constructors are called first in the order they appear in a depth-first, left-to-right traversal of the graph of base classes<\/li>
- constructors for the rest of the classes are then called, from base class to derived class<\/li>
- destructors are called in the opposite order of construction<\/li><\/ul>\n\n\n\n
Let’s look at the following example:<\/p>\n\n\n\n
struct control\n{\n int id;\n int width;\n int height;\n\n control(int const i) :id(i)\n {\n std::cout << \"control ctor\\n\";\n }\n\n virtual ~control()\n {\n std::cout << \"control dtor\\n\";\n }\n\n void resize(int const w, int const h, bool const redraw = true) \n {\n width = w;\n height = h;\n if(redraw)\n draw();\n }\n\n virtual void draw() \n { \n std::cout << \"control::draw\\n\"; \n }\n};\n\nstruct image : virtual public control\n{\n int stretch_style;\n int stretch_direction;\n\n image(int const i) :control(i)\n {\n std::cout << \"image ctor\\n\";\n }\n\n virtual ~image()\n {\n std::cout << \"image dtor\\n\";\n }\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"image::draw\\n\"; \n }\n};\n\nstruct button : virtual public control\n{\n int text_alignment;\n\n button(int const i) :control(i)\n {\n std::cout << \"button ctor\\n\";\n }\n\n virtual ~button()\n {\n std::cout << \"button dtor\\n\";\n }\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"button::draw\\n\"; \n }\n};\n\nstruct image_button : public image, public button\n{\n int content_alignment;\n\n image_button(int const i) : image(i), button(i), control(i)\n {\n std::cout << \"image_button ctor\\n\";\n }\n\n ~image_button()\n {\n std::cout << \"image_button dtor\\n\";\n }\n\n virtual void draw() override\n {\n button::draw();\n image::draw();\n std::cout << \"image_button::draw\\n\";\n }\n};\n\nint main()\n{\n image_button ib{ 3 };\n ib.resize(100, 20);\n}<\/pre>\n\n\n\nThe output of this program is as follows:<\/p>\n\n\n\n
control ctor\nimage ctor\nbutton ctor\nimage_button ctor\ncontrol::draw\nbutton::draw\ncontrol::draw\nimage::draw\nimage_button::draw\nimage_button dtor\nbutton dtor\nimage dtor\ncontrol dtor<\/pre>\n\n\n\n
A class may have both virtual and non-virtual base classes. We can change the previous example in order to demonstrate what happens in this case. Let’s consider the following modified class hierarchy:<\/p>\n\n\n\n
![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/cd3-1.png\")
<\/a><\/figure>\n\n\n\nThe new hierarchy differs from the previous on as follows:<\/p>\n\n\n\n
- the
image<\/code> class has two base classes: non-virtual baseflippable<\/code> and virtual basecontrol<\/code><\/li>- the
button<\/code> class has two base classes also, both virtual:control<\/code> andclickable<\/code><\/li>- the
image_button<\/code> class has three base classes: non-virtual basesimage<\/code> andbutton<\/code>, and virtual base classclickable<\/code><\/li><\/ul>\n\n\n\nThe modified implementation of these classes is shown below:<\/p>\n\n\n\n
struct control\n{\n int id;\n int width;\n int height;\n\n control(int const i) :id(i)\n {\n std::cout << \"control ctor\\n\";\n }\n\n virtual ~control()\n {\n std::cout << \"control dtor\\n\";\n }\n\n void resize(int const w, int const h, bool const redraw = true) \n {\n width = w;\n height = h;\n if(redraw)\n draw();\n }\n\n virtual void draw() \n { \n std::cout << \"control::draw\\n\"; \n }\n};\n\nstruct flippable\n{\n int axis;\n\n flippable()\n {\n std::cout << \"flippable ctor\\n\";\n }\n\n virtual ~flippable()\n {\n std::cout << \"flippable dtor\\n\";\n }\n};\n\nstruct image : public flippable, virtual public control\n{\n int stretch_style;\n int stretch_direction;\n\n image(int const i) :control(i)\n {\n std::cout << \"image ctor\\n\";\n }\n\n virtual ~image()\n {\n std::cout << \"image dtor\\n\";\n }\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"image::draw\\n\"; \n }\n};\n\nstruct clickable\n{\n using fn_clicked = void(*)();\n\n fn_clicked callback = nullptr;\n\n clickable()\n {\n std::cout << \"clickable ctor\\n\";\n }\n\n virtual ~clickable()\n {\n std::cout << \"clickable dtor\\n\";\n } \n};\n\nstruct button : virtual public clickable, virtual public control\n{\n int text_alignment;\n\n button(int const i) :control(i)\n {\n std::cout << \"button ctor\\n\";\n }\n\n virtual ~button()\n {\n std::cout << \"button dtor\\n\";\n }\n\n virtual void draw() override\n { \n control::draw(); \n std::cout << \"button::draw\\n\"; \n }\n};\n\nstruct image_button : public image, public button, virtual public clickable\n{\n int content_alignment;\n\n image_button(int const i) : image(i), button(i), control(i)\n {\n std::cout << \"image_button ctor\\n\";\n }\n\n ~image_button()\n {\n std::cout << \"image_button dtor\\n\";\n }\n\n virtual void draw() override\n {\n button::draw();\n image::draw();\n std::cout << \"image_button::draw\\n\";\n }\n};<\/pre>\n\n\n\nThe new memory layout of the
image_button<\/code> class is shown in the following image:<\/p>\n\n\n\n![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2021\/11\/layout6.png\")
<\/a><\/figure>\n\n\n\nAgain, we can notice several things here:<\/p>\n\n\n\n
- the layout of the
image<\/code> object contains theflippable<\/code> object, as this class is a non-virtual base<\/li>- there is only one copy of the
clickable<\/code> object layout, as this class is a virtual base class for bothbutton<\/code> andimage_button<\/code><\/li>- the memory layout of the two virtual base classes,
control<\/code> andclickable<\/code>, is located at the end of theimage_button<\/code> layout<\/li><\/ul>\n\n\n\nThe new output of the program is listed here:<\/p>\n\n\n\n
control ctor\nclickable ctor\nflippable ctor\nimage ctor\nbutton ctor\nimage_button ctor\ncontrol::draw\nbutton::draw\ncontrol::draw\nimage::draw\nimage_button::draw\nimage_button dtor\nbutton dtor\nimage dtor\nflippable dtor\nclickable dtor\ncontrol dtor<\/pre>\n\n\n\n
The order of the constructor calls, as seen here, as well as the destructor calls is following the several rules listed at the beginning of this section.<\/p>\n\n\n\n
Alternatives<\/h2>\n\n\n\n
Because of this diamond problem, and perhaps because other languages do not support multiple inheritance, there is a considerable opposition to using multiple inheritance. That doesn’t necessary mean that multiple inheritance is evil or it can’t be used successfully in various scenarios. Inheritance in general should be used when it has benefits not for the purpose of reusing code. There are many cases when aggregation is a better solution than inheritance.<\/p>\n\n\n\n
If you do use multiple inheritance, in general, it’s preferred that the virtual base classes are pure abstract base classes. That means only pure virtual methods and, if possible, no data members either. That is basically the equivalent of interfaces in C# or Java. Using this approach, multiple inheritance becomes equivalent to the single inheritance in these other programming languages.<\/p>\n\n\n\n
An alternative to multiple inheritance is using some design patterns. A good example is the bridge design pattern<\/a> that allows you to separate abstractions from the implementations.<\/p>\n\n\n\n
References<\/h2>\n\n\n\n
You can read more about virtual inheritance here: ISO C++: Inheritance – multiple and virtual inheritance<\/a>.<\/p>\n\n\n\n
The memory layout images in this article were created using Struct Layout<\/a> – an extension for Visual Studio.<\/p>\n\n\n\n
The class diagram images in this article were created using Visual Paradigm Online<\/a> – a free tool for drawing class diagrams and other UML diagrams.<\/p>\n","protected":false},"excerpt":{"rendered":"
The C++ language supports the concept of multiple inheritance. This means one class can have multiple base classes. This feature is not available in other languages, such as C# or Java. The designers of these languages didn’t considered the benefits of supporting this feature to worth the effort. And probably one of the reasons is … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,639,640],"class_list":["post-4343","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-inheritance","tag-virtual"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t
- there is only one copy of the
- the
- the
- the data members from the