Why does slicing occur?

Question

Please consider the following code:

Base b;
if (something)
    b = DerivedA();
else
    b = DerivedB();

It's well known that in such a case, 'slicing' occurs: In C++ we can't assign a variable of a base type an object of the derived type; the object would be 'sliced' off anything that isn't defined in the base type. (If we want to do such a thing, we have to use pointers or references).

I want to understand the actual reason for this. I.e., the reason why a Base variable can't hold a Derived object without slicing it.

My assumption is that the reason for this is that a Base object and a Derived object might not be of the same size, thus we can't make guarantees on being able to store an entire Derived object in a Base variable. A Base might take up 4 bytes, while a Derived is 7 bytes. So we settle to always slicing the derived object to fit the size of the base type.

We are able to do this with pointers, because they all occupy the same amount of memory.

Is this assumption correct? If not, what is the actual reason for slicing?

Answer 1

The issue is with copy and move semantics (copy constructor, copy assignment, etc). You are getting a copy of the elements, however not all elements will be copied. If you have a base pointer, there will be no issue.

If you had a fully populated DerivedA object, and assigned that to a local stack base type, a copy assignment will be used, and any derived element values will be discarded.

Consider when you write your copy constructor. Do you do any additional work besides the members of the current class? How would you know what derived from the current class, and what work to do? Attempting to do so would be very bad.

class BaseType
{
private:
    int m_i;

public:
    explicit BaseType(BaseType const & other) // copy ctor
    {
        m_i = other.m_i;   // bitwise copy or memberwise copy will suffer the same issue
        // what else is there to do?  
        // BaseType has no knowledge of any other members
    }

    BaseType & BaseType::operator=(BaseType const & other)  // copy assignment
    {
        m_i = other.m_i;
        // what else is there to do?  
        // BaseType has no knowledge of any other members
    }
};

Even with a bitwise copy (for std::is_trivially_copyable<T>), the size will be of BaseType, and as you point out, smaller than necessary, and will truncate data.

Hope this helps.

Answer 2

No. In your example, the reason for slicing is different.

In the line Base b;, you allocate space for an object of type Base on the stack and already invoke its default constructor. Therefore, in each of the branches of your if-statement, what happens is an assignment to b, which is realized through an assignment operator, usually with signature Base::operator=(const Base&). If you don't overload this operator, its default semantics are a field-by-field copy. Note that the argument type is Base (or const Base&), so only the Base-fields of the right-hand side are visible!

Assuming you had some way of storing all the information contained in a DerivedA object in a Base object (though this is unlikely), you could overload your assignment operator as Base::operator=(const DerivedA&), implement your own assignment semantics, and the above would work perfectly fine.