Object slicing

Object slicing is a concept in C++ that occurs when an object of a derived class is assigned to an object of its base class. In this process, the portion of the derived class (i.e., the members and functionalities specific to the derived class) is "sliced off," leaving only the part of the base class. This happens because the base class object cannot hold the additional members and methods of the derived class.

Why Does Object Slicing Occur?

Object slicing occurs because of value assignment or passing objects by value. When a derived class object is copied into a base class object, only the base class part is copied. The derived class members, which extend the base class, are lost during this assignment.

#include <iostream>

using namespace std;

class Base {

public:

    int baseVar;

    virtual void show() {

        cout << "Base class variable: " << baseVar << endl;

    }

};

class Derived : public Base {

public:

    int derivedVar;

    void show() override {

        cout << "Base class variable: " << baseVar << ", Derived class variable: " << derivedVar << endl;

    }

};

int main() {

    Derived d;

    d.baseVar = 1;

    d.derivedVar = 2;

    Base b = d; // Object slicing happens here

    b.show();   // Outputs: Base class variable: 1

    return 0;

}

Explanation:

In the example above:

1. The Derived class has an additional member derivedVar and overrides the show() method.

2. When Derived object d is assigned to the Base object b, the derivedVar and the overridden show() method in the Derived class are "sliced off."

3. The Base object b retains only the baseVar and the base class version of show().

Consequences of Object Slicing

1. Loss of Derived Class Data: Any additional data members in the derived class are discarded.

2. Polymorphism Breakdown: Virtual functions may not behave as intended if slicing occurs. Instead of using the derived class's overridden function, the base class implementation is used.

3. Bugs in Code: Unexpected behavior can arise if the developer mistakenly assumes the derived class members are still present.

How to Prevent Object Slicing

1. Use References or Pointers: Passing objects by reference or using pointers instead of creating a copy avoids object slicing. For example:

void display(Base& obj) {

    obj.show(); // No object slicing, polymorphism works as intended

}

       2. Use Virtual Functions: Virtual functions and references ensure that the correct implementation of a method is called based on the actual type of the object.