The evolution history of C++ virtual functions: tracing the origins and changes of polymorphic programming

C Virtual functions implement polymorphic programming through dynamic dispatch, and its evolution includes: virtual pointers, virtual function tables, dynamic dispatch, runtime type information (RTTI). In the actual case, the dynamic dispatch behavior of different animal types is demonstrated through the inheritance relationship of the animal class and the virtual function speak(). Virtual functions continue to evolve in C, increasing the efficiency and flexibility of polymorphic programming and becoming a key feature for enabling robust and scalable code.

The evolution history of C virtual functions: the origin and changes of polymorphic programming

Introduction

Virtual functions are a key feature of polymorphic programming in C, which allow subclasses of an object to redefine its behavior without modifying the base class code. This article will trace the origin of virtual functions, explore their evolution in C, and demonstrate their application through practical cases.

Origin: Liskov's Substitution Principle

The concept of polymorphic programming was first proposed by Barbara Liskov in 1987 in her famous Liskov's Substitution Principle. This principle states that any subclass can replace its superclass without changing the correctness of the program.

Early C implementation: virtual pointers

In early versions of C, virtual functions were implemented through virtual pointer tables. Each object contains a pointer to a virtual pointer table, which stores pointers to each of its virtual functions. When a virtual function is called, the compiler uses this pointer table to find the correct function address and execute it.

Introduction of virtual function table

C 2.0 introduces virtual function table, which is a more efficient way to implement virtual functions. The virtual function table is an array that stores virtual function pointers of all objects. The object calls its virtual function by indexing into this array, thus avoiding the overhead of looking up the virtual pointer table.

Dynamic dispatch

Dynamic dispatch is one of the key features of virtual functions. It allows an object to call the correct version of a virtual function at runtime based on its actual type. This is accomplished by storing a pointer to the correct vtable in the object's object table when it is created.

RTTI (Run-time Type Information)

Run-time type information (RTTI) allows a program to determine the type of an object at run time. This allows programs to write robust code that behaves differently depending on the object type. In C, RTTI is implemented through the typeid and dynamic_cast operators.

Practical Case: Animal Garden Simulation

Consider a program that simulates a zoo. Each Animal class derives from a base class, Animal, which defines common behaviors shared by all animals (eat() and sleep()). Different kinds of animals can define their own speak() methods, whose behavior varies depending on the animal type.

class Animal {
public:
    virtual void eat() = 0;
    virtual void sleep() = 0;
};

class Dog : public Animal {
public:
    void eat() override { cout << "Dog eating" << endl; }
    void sleep() override { cout << "Dog sleeping" << endl; }
    void speak() { cout << "Woof!" << endl; }
};

class Cat : public Animal {
public:
    void eat() override { cout << "Cat eating" << endl; }
    void sleep() override { cout << "Cat sleeping" << endl; }
    void speak() { cout << "Meow!" << endl; }
};

In the main program, we can create various animal objects and call their virtual functions, thus demonstrating dynamic dispatch:

int main() {
    Animal* dog = new Dog();
    Animal* cat = new Cat();

    dog->speak(); // 输出 "Woof!"
    cat->speak(); // 输出 "Meow!"

    return 0;
}

Conclusion

As C has evolved from early to modern versions, the development of virtual functions has undergone significant changes. From virtual pointers to virtual function tables to dynamic dispatch, these evolutions have improved the efficiency and flexibility of polymorphic programming. Virtual functions remain a core feature in C for enabling robust and scalable code.

The above is the detailed content of The evolution history of C++ virtual functions: tracing the origins and changes of polymorphic programming. For more information, please follow other related articles on the PHP Chinese website!