How Does Slicing Affect Polymorphism in C ?

Polymorphism and Slicing in C

In C , polymorphism allows you to create objects with different functionality based on their derived class. However, it can lead to strange behavior if not handled carefully. One such issue is "slicing."

Consider the following code:

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() { cout << "rawr" << endl; }
};

class Dog : public Animal {
public:
    virtual void makeSound() { cout << "bark" << endl; }
};

int main() {
    Animal animal;
    animal.makeSound();

    Dog dog;
    dog.makeSound();

    Animal badDog = Dog();
    badDog.makeSound();

    Animal* goodDog = new Dog();
    goodDog->makeSound();
}

The output you get is:

rawr
bark
rawr
bark

You might expect the output to be "rawr bark bark bark," but instead, the object badDog behaves as an Animal instead of a Dog. This is because of slicing.

When you create badDog as Animal badDog = Dog(), you're slicing the Dog object into an Animal. This means that badDog only contains the parts of the Dog that are part of the Animal class, and all the specific Dog functionality is lost.

To fix this, you need to use pointers or references to derive classes. Pointers or references don't copy the object, so they can retain their specific functionality. For example, the goodDog pointer successfully retains its Dog functionality.

Some languages like Java have reference semantics by default, while C uses value semantics. In C , you explicitly need to use pointers or references to achieve reference semantics. Failing to do so can lead to slicing issues, as demonstrated in the badDog example.

The above is the detailed content of How Does Slicing Affect Polymorphism in C ?. For more information, please follow other related articles on the PHP Chinese website!