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.
The assignment you've shown doesn't make too much sense. Yes, the array as you show it will be contiguous, but it won't have space for any of the derived class members, and when you perform that assignment those data will be dropped (if the compiler even permits it, which I'm not sure it will).