Application skills of virtual functions and pure virtual functions in C++

Virtual functions and pure virtual functions in C are common tools for many programmers using object-oriented programming. Under the premise of using them correctly, the flexibility and maintainability of the program can be greatly improved. This article will discuss the application skills of virtual functions and pure virtual functions, and share some practical development experiences.

1. Virtual function

1. What is a virtual function?

Virtual function is a technology used to implement polymorphism, which allows the member functions of a class to be dynamically determined at runtime. When a virtual function is called using a base class pointer or reference, the program determines which function to call based on the type of the actual object, thus achieving runtime polymorphism.

2. Application scenarios of virtual functions

• The base class pointer or reference points to the derived class object and needs to implement polymorphism;
• Some functions in the base class Needs to be redefined in derived classes.

3. Precautions for using virtual functions

• Virtual functions can be overridden by derived classes, but cannot be overloaded by derived classes;
• If virtual functions If it is not overridden, the default implementation in the base class is called;
• The constructor cannot be a virtual function.

2. Pure virtual function

1. What is a pure virtual function?

A pure virtual function is a virtual function without a defined implementation. Its definition form is "virtual function type function name () = 0;", where the 0 after the equal sign indicates that the function is a pure virtual function. Pure virtual functions must be redefined in derived classes, otherwise compilation errors will result.

2. Application scenarios of pure virtual functions

• The base class defines a function interface, but cannot provide a default implementation;
• The base class hopes to force derived classes Implement a function to meet specific needs.

3. Precautions for using pure virtual functions

• As long as a pure virtual function is defined in a class, it becomes an abstract class and objects of this class cannot be defined;
• The derived class must implement the pure virtual function in the base class, otherwise it will cause a compilation error;
• If the derived class does not implement a pure virtual function in the base class, the derived class will also become abstract class.

3. Application skills of virtual functions and pure virtual functions

1. Use virtual functions to achieve polymorphism

Virtual functions can realize polymorphism very conveniently. Let different objects show different behaviors at runtime to improve the flexibility of the program. The following is an example:

class Shape {
public:
    virtual void draw() {
        // 基类默认实现
    }
};

class Circle : public Shape {
public:
    void draw() {
        // 具体实现
    }
};

class Square : public Shape {
public:
    void draw() {
        // 具体实现
    }
};

int main() {
    Shape* p = new Circle();
    p->draw();  // 调用圆形的实现

    p = new Square();
    p->draw();  // 调用正方形的实现

    return 0;
}

By defining the draw function of Shape as a virtual function, we can use the base class pointer to call the implementation of different derived classes at runtime, achieving polymorphism.

2. Use pure virtual functions to define interfaces

Defining pure virtual functions can define the base class as an interface class and force the derived class to implement a specific interface. The following is an example:

class Interface {
public:
    virtual void func1() = 0;
    virtual int func2() = 0;
};

class Implement : public Interface {
public:
    void func1() {
        // 具体实现
    }

    int func2() {
        // 具体实现
    }
};

int main() {
    Interface* p = new Implement();

    p->func1();
    cout << p->func2() << endl;

    return 0;
}

By defining the functions in Interface as pure virtual functions, we can force the Implement class to implement these functions, thus defining Interface as an interface class.

3. Avoid calling virtual functions in constructors and destructors

The call of virtual functions is determined dynamically at runtime, so call virtual functions in constructors and destructors , may lead to unexpected results. Therefore, we need to avoid calling virtual functions in constructors and destructors.

4. Summary

This article introduces the basic concepts and usage of virtual functions and pure virtual functions in C, and shares some application skills. During the program development process, we can flexibly use virtual functions and pure virtual functions according to specific needs, thereby improving the flexibility and maintainability of the program. At the same time, care needs to be taken to avoid calling virtual functions in constructors and destructors to avoid potential errors.

The above is the detailed content of Application skills of virtual functions and pure virtual functions in C++. For more information, please follow other related articles on the PHP Chinese website!