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: 
> 
> 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`
> 
> 
> 

The `people` array cannot contain `Adult` or `Child` objects: it can only contain `Person` objects.

When you perform the assignment `people[0] = child1;`, what actually happens is the `Person` parts of the `child1` object are assigned to `people[0]`. All of the `Child` parts are effectively ignored.

This behavior, where only the base class parts of an object are copied, is called "slicing."

To get polymorphic behavior in C++, you must use either pointers are references. Since it is impossible to have an array of references, you would need to use an array of pointers.
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.