How to make an array with polymorphism in C++? [duplicate]

Answer 1

You're getting the error because the array is statically typed to Base1. That means that this line:

pBase[1].GetRow();

adds the size of Base1 in bytes to pBase and interprets this as the beginning of another Base1 object, but this actually points someplace into the middle of the first table instance.

If you need an array of polymorphic instances, you must store them in the array (or preferably in a std::vector) via pointers (or preferably some form of smart pointers).

Answer 2

You need to create (with new) all those array elements, do it like this:

for(int i = 0; i < 3; ++i)
    pBase[i] = new table();

Answer 3

In C++, polymorphism and arrays don't mix.

Since in general the size of the derived class is different to the size of the base class, polymorphism and pointer arithmetic don't play together nicely. Since array access involves pointer arithmetic, expressions such as pBase[1] don't work as expected.

One possibility is to have an array of pointers to your objects, perhaps even smart pointers to simplify memory management. But don't forget to define a virtual destructor in Base1.

Answer 4

Agnew's response was spot on. Let me explain a little more. By augmenting your code, I print out the size of a Base1 and a table object as well as the addresses of the three table objects as they are created by the new operator:

A Base1 object is 8 bytes
A table object is 12 bytes
A table object is being constructed at 0x002977C0
A table object is being constructed at 0x002977CC
A table object is being constructed at 0x002977D8

As you can see those objects are spaced 12 bytes apart from each other in memory.

Now, let's print out the addresses that pBase[0], pBase[1] and pBase[2] give:

pBase[0] is at 0x002977C0
pBase[1] is at 0x002977C8
pBase[2] is at 0x002977D0

Now look at what happens: the pointers we get back are spaced 8 bytes apart. This is because the pointer arithmetic is done on an pointer whose type is Base1 and since Base1 is 8 bytes longs what the compiler does is to translate pBase[n] into pBase + (n * sizeof(Base1)).

Now you should be able to understand exactly why the first GetRow() works and why you crash on the second.