Comment le polymorphisme en C++ aide-t-il à créer du code flexible et évolutif ?

Le polymorphisme C++ permet d'utiliser les objets de plusieurs manières, implémentées via des fonctions virtuelles et des tables virtuelles. Cela fait que les objets de classe dérivée se comportent différemment de la classe de base : les fonctions virtuelles permettent de remplacer les fonctions de la classe de base dans les classes dérivées. La table virtuelle enregistre les pointeurs vers les adresses de fonctions virtuelles et recherche et appelle dynamiquement les fonctions appropriées en fonction du type d'objet. Des exemples pratiques montrent comment utiliser le polymorphisme pour créer des collections dynamiques d'objets, ajuster leur comportement en fonction de leurs types et augmenter la flexibilité du code.

Polymorphisme en C++ : un outil puissant pour la flexibilité et l'évolutivité

Vue d'ensemble

Le polymorphisme est un principe de base de la programmation orientée objet (POO) qui permet d'utiliser des objets de nombreuses manières différentes. Pour ce faire, il permet aux objets de classe dérivée de se comporter différemment de leur classe de base.

Implémentation du polymorphisme

En C++, le polymorphisme peut être obtenu en utilisant des fonctions virtuelles et des tables virtuelles. Une fonction virtuelle est une fonction qui permet de remplacer une fonction de classe de base dans une classe dérivée. Une table virtuelle est une table qui contient des pointeurs vers des adresses de fonctions virtuelles.

Fonctions virtuelles

class Base {
public:
    virtual void display() {
        cout << "Base class display function" << endl;
    }
};

class Derived : public Base {
public:
    virtual void display() override {
        cout << "Derived class display function" << endl;
    }
};

Dans l'exemple ci-dessus, la fonction display de la classe Base est une fonction virtuelle dans la classe dérivée Derived</code > est couvert. <code>Base 类的 display 函数是虚函数，在派生类 Derived 中被覆盖。

虚表

虚表包含指向 Base 类和 Derived 类的 display 函数地址的指针：

class Base {
public:
    virtual void display() {
        cout << "Base class display function" << endl;
    }
};

class Derived : public Base {
public:
    virtual void display() override {
        cout << "Derived class display function" << endl;
    }
};

int main() {
    Base* ptr = new Derived(); // 指向 Derived 对象的 Base 类指针
    ptr->display(); // 调用 Derived 类中的 display 函数
}

在上述示例中，尽管我们使用的是 Base 类指针，但该指针实际指向派生类 Derived 的一个对象。当调用 display 函数时，它会根据指向的实际对象类型动态查找并调用适当的函数。

实战案例：形状类层次结构

考虑一个形状类层次结构，其中有 Shape 基类和 Circle 和 Rectangle 派生类。Shape 类具有计算面积的虚函数。

class Shape {
public:
    virtual float area() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    Circle(float radius) : mRadius(radius) {}
    float area() override {
        return 3.14 * mRadius * mRadius;
    }

private:
    float mRadius;
};

class Rectangle : public Shape {
public:
    Rectangle(float width, float height) : mWidth(width), mHeight(height) {}
    float area() override {
        return mWidth * mHeight;
    }

private:
    float mWidth;
    float mHeight;
};

在主函数中，我们可以使用 Shape 类指针来存储不同形状对象的引用，并调用 area

Table virtuelle

La table virtuelle contient des pointeurs vers les adresses des fonctions display de la classe Base et de la classe Derived :

int main() {
    Shape* shapes[] = {new Circle(5), new Rectangle(10, 5)};

    for (Shape* shape : shapes) {
        cout << "Area: " << shape->area() << endl;
    }

    return 0;
}

Dans l'exemple ci-dessus, bien que nous utilisions un pointeur de classe Base, le pointeur pointe en fait vers un objet de la classe dérivée Derived. Lorsque la fonction display est appelée, elle recherche et appelle dynamiquement la fonction appropriée en fonction du type d'objet réel pointé. 🎜🎜🎜Cas pratique : Hiérarchie des classes de formes 🎜🎜🎜Considérons une hiérarchie de classes de formes avec la classe de base Shape et les classes dérivées Circle et Rectangle. La classe Shape possède des fonctions virtuelles pour calculer la surface. 🎜rrreee🎜Dans la fonction principale, nous pouvons utiliser le pointeur de classe Shape pour stocker des références à différents objets de forme et appeler la fonction area pour calculer leurs aires : 🎜rrreee🎜🎜 Conclusion 🎜🎜🎜Le polymorphisme en C++ offre une grande flexibilité et évolutivité. Il permet la création de collections dynamiques d'objets dont le comportement peut être ajusté en fonction de leur type réel. Cela permet aux programmeurs de créer un code plus maintenable et plus facile à étendre. 🎜

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!