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

Question

class Base1
{
    private:
     int testInput; 
    public:
       Base1();
       virtual int GetRow(void) = 0;
 };

 Base1::Base1()
 {
   testInput = 0;
 }

class table : public Base1
{
   private:
    int row;    
   public:  
     table();
     virtual int GetRow(void);
};

table::table()
{   
  //Contructor
  row = 5;
}

int table::GetRow()
{
  return row;
}

int main ()
{
  Base1* pBase = new table[3];
  pBase[0].GetRow();
  pBase[1].GetRow();   //when i get to  this line, the compiler keep saying access
                           // violation.
  pBase[2].GetRow();

  return 0;
}

I'm trying to create an array of 3 table class. The requirement is I have to use Base object to do that.

Base1 * pBase = new table[3];  

look fine to me. But when I tried to access each table, the compiler said it's access violation. I don't know what wrong with this code. I'm using Visual Studio 2010 though.

Answer 1

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 2

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 3

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.