Home >Backend Development >C++ >How Can Object Slicing Be Avoided in C to Achieve Polymorphic Behavior?
Object Slicing and Polymorphic Behavior
In object-oriented programming, storing derived class objects in base class variables can lead to unexpected behavior known as object slicing. This issue occurs when the base class variable is assigned an object of a derived class, resulting in the derived class-specific members being lost due to object slicing.
Example:
Consider the following program:
#include <iostream> #include <vector> using namespace std; class Base { public: virtual void identify() { cout << "BASE" << endl; } }; class Derived : public Base { public: virtual void identify() { cout << "DERIVED" << endl; } }; int main() { Derived derived; vector<Base> vect; vect.push_back(derived); vect[0].identify(); return 0; }
In this example, a derived class object derived is stored in a vector of base class objects vect. However, when calling the identify() method on the base class object vect[0], it outputs "BASE" instead of the expected "DERIVED".
Solution:
To prevent object slicing and achieve polymorphic behavior, the correct approach is to store a pointer to the base class in the vector:
vector<Base*> vect;
By using a pointer, the derived class-specific members are preserved, allowing for the desired polymorphic behavior.
Enhanced Solution Using Smart Pointers:
To ensure proper memory management, it is recommended to use a suitable smart pointer instead of a raw pointer:
vector<unique_ptr<Base>> vect;
This ensures that the memory for the base class objects is automatically managed using Resource Acquisition Is Initialization (RAII), making the code more efficient and robust.
The above is the detailed content of How Can Object Slicing Be Avoided in C to Achieve Polymorphic Behavior?. For more information, please follow other related articles on the PHP Chinese website!