Actual object memory layout can be a little tricky when inheritance and its virtual tables are involved. And it gets even trickier when pointer arithmetic is employed. Do you consider yourself a low-level expert?

Let us consider the following main program:

#include <iostream>

void f (A *a) {
    std::cout << a[2].x << std::endl;
}

int main () {
    B b[10];
    f(b);
}

In this post we will present three different definitions for classes A and B. Each definition will vary slightly from the previous one, and is likely to generate different output.

The first definition is the most straight forward:

// version I

struct A {
    A () : x(1) {}
    unsigned x;

    void dummy () {}
};

struct B : A {
    B () : y(2) {}
    unsigned y;

    void dummy () {}
};

As you could guess: we have defined two classes – A, and B which inherits from A. B contains one member – x, which is initialized to 1. B contains an extra member – y, which is initialized to 2. What will this version print?

At this point we shall add an innocent ‘virtual’ specification to the member function B::dummy:

// version II

struct A {
    A () : x(1) {}
    unsigned x;

    void dummy () {}
};

struct B : A {
    B () : y(2) {}
    unsigned y;

    virtual void dummy () {}
};

What will now be printed?

We shall be fair and let A have its own ‘virtual’ qualifier as well:

// version III

struct A {
    A () : x(1) {}
    unsigned x;

    virtual void dummy () {}
};

struct B : A {
    B () : y(2) {}
    unsigned y;

    virtual void dummy () {}
};

What do you expect to be printed now?

… .. .

Hint: Each of the suggested implementations generates a different output.