Comment le polymorphisme et le découpage affectent-ils le comportement des objets en C ?

Polymorphisme et découpage en C

Lorsqu'ils traitent de l'héritage, les programmeurs C peuvent rencontrer le problème du découpage. Considérez le code suivant :

#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();
}

Ce code produit le résultat suivant :

rawr
bark
rawr
bark

Cela peut être surprenant, car on pourrait s'attendre à ce que le résultat soit "rawr bark bark bark" à la place . La différence réside dans l'utilisation du découpage dans l'affectation badDog :

Animal badDog = Dog();

Dans ce cas, les données du chien sont découpées dans l'objet Animal, entraînant une perte d'informations spécifiques au chien. En effet, Dog() crée un objet Dog, mais lors de son affectation à badDog, qui est un objet Animal, seule la partie Animal du Dog est copiée.

Pour éviter le découpage, on peut utiliser des pointeurs ou références :

Animal* badDogPtr = new Dog();
Animal& goodDogRef = dog;

Les pointeurs et les références se comportent comme prévu et permettent un comportement polymorphe. En effet, ils font référence ou détiennent une référence à l'objet, plutôt que d'en avoir une copie comme dans le cas de la sémantique des valeurs.

Dans des langages comme Java et C#, la sémantique de référence est la valeur par défaut, tandis que dans C , la sémantique des valeurs est la valeur par défaut. Pour un comportement polymorphe en C , l'utilisation explicite de références ou de pointeurs est nécessaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!