Implementation of C++ polymorphism and analysis of common problems

Realization of C Polymorphism and Analysis of Common Problems

Introduction:
Polymorphism is an important feature of object-oriented programming languages, and it is also used in C Has been widely used. Polymorphism allows different types of objects to be processed in the same way, improving code flexibility and maintainability. This article will introduce the implementation of polymorphism in C and analyze common polymorphism problems.

1. How to implement polymorphism

1. Virtual functions (Virtual Functions)
   Virtual functions are the basis of polymorphism in C. By declaring a member function of a base class as a virtual function, you can override it in a derived class. When a virtual function is called through a pointer or reference to a base class object, the function in the derived class is actually executed. The following is a sample code:

class Shape{
public:
    virtual void draw() {
        cout << "This is a shape." << endl;
    }
};

class Circle : public Shape{
public:
    void draw() {
        cout << "This is a circle." << endl;
    }
};

class Rectangle : public Shape{
public:
    void draw() {
        cout << "This is a rectangle." << endl;
    }
};

int main(){
    Shape* shape = new Circle();
    shape->draw();  // 输出 "This is a circle."
    
    shape = new Rectangle();
    shape->draw();  // 输出 "This is a rectangle."
    
    delete shape;
    return 0;
}

2. Pure Virtual Functions and Abstract Classes
   Pure virtual functions refer to those declared in the base class but not implemented Virtual functions are marked with "= 0". Pure virtual functions are only used for implementation in derived classes, base classes cannot instantiate objects. In C, a class containing pure virtual functions is called an abstract class. Abstract classes cannot be instantiated directly and can only be instantiated and used through derived classes. The following is a sample code:

class Shape{
public:
    virtual void draw() = 0;
};

class Circle : public Shape{
public:
    void draw() {
        cout << "This is a circle." << endl;
    }
};

class Rectangle : public Shape{
public:
    void draw() {
        cout << "This is a rectangle." << endl;
    }
};

int main(){
    Shape* shape = new Circle();
    shape->draw();  // 输出 "This is a circle."
    
    shape = new Rectangle();
    shape->draw();  // 输出 "This is a rectangle."
    
    delete shape;
    return 0;
}

2. Analysis of common problems

1. Pointer type issues
   When using polymorphism, you need to pay attention to pointer type issues. Since a derived class object can be assigned to a pointer or reference pointing to a base class object, when a method is called through a virtual function, the function to be called will be determined based on the pointer type. If the pointer type is incorrect, the correct derived class function will not be called. Here is an example:

class Shape{
public:
    virtual void draw(){
        cout << "This is a shape." << endl;
    }
};

class Circle : public Shape{
public:
    void draw(){
        cout << "This is a circle." << endl;
    }
};

class Rectangle : public Shape{
public:
    void draw(){
        cout << "This is a rectangle." << endl;
    }
};

int main(){
    Shape* shape = new Shape();
    shape->draw();  // 输出 "This is a shape."
    
    shape = new Circle();
    shape->draw();  // 输出 "This is a circle."
    
    shape = new Rectangle();
    shape->draw();  // 输出 "This is a rectangle."
    
    delete shape;
    return 0;
}

2. Calling order issue
   In polymorphism, the calling order of virtual functions is determined based on the actual type of the pointer or reference. If you call a virtual function in a constructor or destructor, it may lead to unexpected results. This is because the type of the object is determined when the constructor or destructor is called, and the call to the virtual function is based on subsequent assignment operations. The following is an example:

class Shape{
public:
    Shape(){
        draw();  // 虚函数调用
    }
    
    virtual void draw(){
        cout << "This is a shape." << endl;
    }
};

class Circle : public Shape{
public:
    void draw(){
        cout << "This is a circle." << endl;
    }
};

int main(){
    Shape* shape = new Circle();
    shape->draw();  // 输出 "This is a shape." 和 "This is a circle."
    
    delete shape;
    return 0;
}

Summary:
This article introduces the implementation of polymorphism in C and analyzes common polymorphism issues. By understanding the basic concepts and usage of polymorphism, you can improve the flexibility and maintainability of your code and better cope with daily development needs. However, when using polymorphism, you need to pay attention to issues such as pointer types and calling order to avoid unexpected results. I hope this article can help readers better understand and apply polymorphism.

The above is the detailed content of Implementation of C++ polymorphism and analysis of common problems. For more information, please follow other related articles on the PHP Chinese website!