How does polymorphism in C++ help create flexible and scalable code?

C++ Polymorphism allows objects to be used in multiple ways, implemented through virtual functions and virtual tables. It makes derived class objects behave differently from base class: virtual functions allow base class functions to be overridden in derived classes. The virtual table saves pointers to virtual function addresses and dynamically finds and calls the appropriate function based on the object type. Practical examples show how to use polymorphism to create dynamic collections of objects, adjust their behavior based on their types, and increase code flexibility.

Polymorphism in C++: A powerful tool for flexibility and scalability

Overview

Polymorphism is a fundamental principle in object-oriented programming (OOP) that allows objects to be used in many different ways. It does this by allowing derived class objects to behave differently from their base class.

Implementing polymorphism

In C++, polymorphism can be achieved by using virtual functions and virtual tables. A virtual function is a function that allows a base class function to be overridden in a derived class. A virtual table is a table that holds pointers to virtual function addresses.

Virtual function

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;
    }
};

In the above example, the display function of the Base class is a virtual function, in the derived Overridden in class Derived.

Virtual table

The virtual table contains display functions that point to the Base class and the Derived class Pointer to address:

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 函数
}

In the above example, although we are using the Base class pointer, the pointer actually points to an object of the derived class Derived. When the display function is called, it dynamically finds and calls the appropriate function based on the actual object type pointed to.

Practical Case: Shape Class Hierarchy

Consider a shape class hierarchy with a Shape base class and a Circle and Rectangle derived classes. Shape class has virtual functions for calculating area.

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;
};

In the main function, we can use the Shape class pointer to store references to different shape objects and call the area function to calculate their areas:

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

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

    return 0;
}

Conclusion

Polymorphism in C++ provides great flexibility and scalability. It allows the creation of dynamic collections of objects whose behavior can be adjusted based on their actual type. This enables programmers to create code that is more maintainable and easier to extend.

The above is the detailed content of How does polymorphism in C++ help create flexible and scalable code?. For more information, please follow other related articles on the PHP Chinese website!