Question: I've got a question about how a C++ compiler knows how much space it needs to allocate for an object when using inheritance. 

Imagine the following classes, for an adult and a child which extend a Person class, but where a child has a short book with them.

```
class Person
{

};

class Adult : public Person
{
    //No book
};

class Child : public Person
{
   char book[1000]; //Stores the book
};

```

Now if you create an array of Person objects, and add objects to them:

```
Adult adult1;
Child child1;

Person people[2];
people[0] = child1;
people[1] = adult1;

```

My question is: 
How does the compiler know how much space it needs to ensure the array is a contiguous memory block, if it doesn't know whether the array will be filled with Adult or Child (which are much different sizes) objects?

I hope this makes enough sense to answer...

Thanks

Answer: 
Since your array is of type Person, the compiler *doesn't* know to declare enough space for children and adults. It just declares enough for two people.

Each time you put in a child or adult, the object will get "sliced" off, keeping only the Person part of the object.

The standard way to get around this is to declare an array of People pointers (which are all of constant size regardless of what they point to, since they're really just memory addresses), which can point to objects of any of your classes.
In a nutshell, there is no such thing as a virtual constructor in C++, when creating an object you have to know exactly what you are creating. Once the object is created, you can use polymorphism derived class specific behaviour from a base class. In your case when creating a `Person` object only a `Person` object is created. If `Person` has a pure virtual method, the compiler will refuse to create it.

In the event that you are unsure whether to create a `Parent` or a `Child` Object you can use a polymorphic Abstract `PersonFactory` although when creating the factory, for the same reason, you will have to know exactly what type of concrete object you are creating.