I was working the last 5 years with the assumption that virtual inheritance breaks static composition.
But now I discovered, that static composition is still maintained, there is just additional information about the location of the correct instance. Is this right?
class Point2d {
int x_, y_;
};
class Point3d : public Point2d {
int z_;
};
+--------------+
| int x_ |
+--------------+
| int y_ |
+--------------+
+--------------+ --+
| int x_ | |
+--------------+ +-- Point2d subobject
| int y_ | |
+--------------+ --+
| int z_ |
+--------------+
Point3d is statically composed of Point2d and the member of Point3d.
Implemented with an offset variable inside the object.
class Point3d : public virtual Point2d {
int z_;
};
+-----------------+
| int z_ |
+-----------------+
| Point2d* _vbase | --> offset to Point2d subobject (2 in this case)
+-----------------+ --+
| int x_ | |
+-----------------+ +-- Point2d subobject
| int y_ | |
+-----------------+ --+
Accessing Point3d* point3d->x_ in this context will be translated to (C++ Pseudocode):
(static_cast<Point2d*>(point3d) + point3d->_vbase)->x_
Note that there are different ways to implement virtual inheritance like offset pointers inside the vtable, this is just one way to implement virtual inheritance. I chose this one because indirection via vtables would require more ascii drawing.
Virtual inheritance has no benefit here and I would expect (as @Matthieu noted in the comments) a compiler to optimize this class so that it's internal data layout is the same as in non-virtual inheritance. Virtual inheritance is only beneficial in multiple inheritance (see Vertex3d class below).
class Vertex : virtual Point2d {
Vertex* next_;
};
class Vertex3d : public Point3d, public Vertex {
};
+-----------------+
| Vertex* next_ |
+-----------------+
| Point2d* _vbase | --> offset of Point2d subobject (2 in this case)
+-----------------+ --+
| int x_ | |
+-----------------+ +-- Point2d subobject
| int y_ | |
+-----------------+ --+
+------------------+ --+
| int z_ | |
+------------------+ +-- Point3d subobject
| Point2d* _vbase1 | |--> offset to Point2d subobject (4 in this case)
+------------------+ --+
| Vertex* next_ | |
+------------------+ +-- Vertex subobject
| Point2d* _vbase2 | |--> offset to Point2d subobject (2 in this case)
+------------------+ --+
| int x_ | |
+------------------+ +-- shared Point2d subobject
| int y_ | | both Point3d and Vertex point to this
+------------------+ --+ single copy of Point2d
In virtual multiple inheritance both base classes Vertex and Point3d share the base Point2d in Vertex3d. non-virtual inherited members are layed out as usual.
The point of virtual multiple inheritance is that all descendants of Point3d and Vertex will share one copy of Point2d. Without virtual multiple inheritance (= "ordinary" multiple inheritance) both the Point3d subobject and the Vertex subobject of Vertex3d would have its own copy of Point2d:
Vertex3d without virtual multiple inheritance:+------------------+ --+
| int z_ | |
+------------------+ +-- Point3d subobject --+
| int x_ | | |
+------------------+ | +-- Point2d subobject
| int y_ | | | of Point3d
+------------------+ --+ --+
| Vertex* next_ | |
+------------------+ +-- Vertex subobject --+
| int x_ | | |
+------------------+ | +-- Point2d subobject
| int y_ | | | of Vertex
+------------------+ --+ --+
struct X : A, C, D {}; where C and D virtually inherit B. Will B be only part of X (can it be actually before A?), or will B be already part of C, or is it irrelevant since it will be after A and therefore it doesn't matter if we consider B part of X or already C (which is part of X anyway).
Objects of classes that use virtual inheritance have a fixed memory layout that is determined in compilation time. Accessing the virtual base however requires a level of indirection since you cannot tell where it is relative to the derived pointer.
See Wikipedia
Maybe I'm dumb, but I don't understand what you mean by "static composition." You say pimpl breaks it, so let's start with that and take polymorphism and virtual inheritance out of it.
Suppose you have this code:
#include <iostream>
using namespace std;
class Implementation
{
public:
bool do_foo() { return true; }
};
class Implementation2
{
public:
bool do_foo() { return false; }
private:
char buffer_[1024];
};
class Interface
{
public:
Interface(void* impl) : impl_(impl) {};
bool foo() { return reinterpret_cast<Implementation*>(impl_)->do_foo(); }
void change_impl(void* new_impl) { impl_ = new_impl; }
private:
void* impl_;
};
int main()
{
Implementation impl1;
Implementation2 impl2;
Interface ifc(&impl1);
cout << "sizeof(ifc+impl1) = " << sizeof(ifc) << "\n";
Interface ifc2(&impl2);
cout << "sizeof(ifc2+impl2) = " << sizeof(ifc2) << "\n";
ifc.change_impl(&impl2);
cout << "sizeof(ifc+impl2) = " << sizeof(ifc) << "\n";
cout << "sizeof(impl) = " << sizeof(impl1) << "\n";
cout << "sizeof(impl2) = " << sizeof(impl2) << "\n";
}
When you say "breaks static composition" do you mean the sizeof things change as you change out the pimpl in the interface?