Virtual functions are the key mechanism for implementing polymorphism in C, allowing the function version of a derived class to be called through base class pointers or references. 1. The virtual function is declared as virtual in the base class and can be rewritten in the derived class; 2. When using virtual functions, the actual function version of the type to which the object belongs; 3. C realizes dynamic binding through virtual function tables (vtables) and virtual pointers (vptr), bringing certain performance overhead and increasing the object size; 4. If the destructor is inherited, it should be declared as a virtual function, and the static function and constructor cannot be virtual functions; 5. It is recommended to use virtual functions only when needed, combine the override keyword to explicitly rewrite, and use pure virtual functions to force derived classes to implement specific methods; 6. Be careful to avoid calling virtual functions in constructors or destructors, and the default parameters must be consistent to prevent misunderstandings.

Virtual functions in C are key mechanisms used to implement polymorphism. Simply put, it allows us to call the function version of the derived class through a pointer or reference, rather than the base class's own version.

What is a virtual function?

Virtual functions are member functions declared as virtual in the base class and can be override in derived classes. When you call this function through a base class pointer or reference, the actual execution is the function version of the type to which the object belongs.

Let's give a simple example:

 #include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Dog barks" << endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->sound(); // Output: Dog barks
    delete animal;
    return 0;
}

In this example, animal is a pointer to Animal , but it actually points to a Dog object. Since sound() is a virtual function, the Dog version is called.

Virtual function table and runtime binding

C uses virtual function tables (vtables) to support dynamic binding. Each class with virtual functions has a virtual function table, which stores the actual addresses of each virtual function. When the object is created, a pointer (vptr) to this table is saved.

This means:

• Virtual functions bring certain performance overhead (indirect addressing)
• The object size of the class will increase (because vptr is stored)
• If polymorphism is not needed, don't add virtual at will

The following points should be paid attention to when using virtual functions:

• If the destructor is possible, it is best to declare it as a virtual function, otherwise it may cause resource leakage.
• Static functions cannot be virtual functions
• The constructor cannot be a virtual function either (because the object has not been fully constructed yet)

How to use virtual functions correctly?

If you intend to have a class inherited as a base class and want the subclass to override certain methods, then these methods should be declared as virtual functions.

suggestion:

• Use virtual functions only when needed
• When providing a default implementation to a derived class, virtual functions can be retained but not forced to override
• Use the override keyword to explicitly indicate that you are rewriting the parent class method to avoid spelling errors
• If you want to force a derived class to implement a method, you can set it as a pure virtual function ( = 0 ), so that the base class becomes an abstract class

For example:

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

In this way, any class that inherits Shape must implement draw() method.

Pay attention to small details

• If you accidentally forget to set the function as a virtual function, then the multimorphism will not take effect
• Calling virtual functions in constructors or destructors will not trigger polymorphic behavior (because the object has not been constructed or has been deconstructed)
• Virtual functions can have default parameters, but it is recommended to keep them consistent, otherwise it will easily cause misunderstandings.

Basically that's it. Virtual functions are the core of C polymorphism, and understanding them is very helpful in writing flexible and extensible code.

The above is the detailed content of C virtual function example. For more information, please follow other related articles on the PHP Chinese website!