C++ virtual function table and polymorphic implementation, how to avoid memory waste

Virtual base classes can optimize virtual function table memory overhead by allowing inheritance from multiple base classes without creating additional virtual function tables. In the optimized code, the shape base class no longer has a virtual function table, and the circle and rectangle classes share the same virtual function table, thus reducing memory consumption.

C++ virtual function table and polymorphic implementation: avoiding memory waste

Introduction

Polymorphism is a key feature in object-oriented programming that allows objects to exhibit different behaviors depending on their type. In C++, polymorphism is implemented through virtual function tables. However, vtables can cause memory waste, especially if there are a large number of objects.

Virtual function table

The virtual function table is a table that contains pointers to virtual functions. When a virtual function is called, the compiler uses the virtual function table to find the correct function implementation. This ensures that the object can call the correct functions defined for its type.

Waste of memory

The virtual function table takes up memory space. For each class, a vtable is created, even if there are no virtual functions in the class. For applications with a large number of objects, this can cause significant memory overhead.

Optimization: Use virtual base classes

One way to avoid virtual function table memory waste is to use virtual base classes. Virtual base classes allow inheritance from multiple base classes without creating additional virtual function tables.

Practical case

Consider the following class hierarchy:

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

class Circle : public Shape {
public:
  void draw() override {
    // Draw a circle
  }
};

class Rectangle : public Shape {
public:
  void draw() override {
    // Draw a rectangle
  }
};

Before optimization:

In the above In the implementation, Shape, Circle, and Rectangle have their own vtables. This wastes memory space because Shape has no virtual functions.

After optimization through virtual base class:

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

class Shape : public ShapeBase {
};

class Circle : public Shape {
public:
  void draw() override {
    // Draw a circle
  }
};

class Rectangle : public Shape {
public:
  void draw() override {
    // Draw a rectangle
  }
};

Optimization result:

By using virtual base classShapeBase , Circle and Rectangle can now share the same vtable. This eliminates the Shape vtable, thereby reducing memory overhead.

Conclusion

By using virtual base classes, you can avoid the memory waste caused by the virtual function table in C++. Doing so can improve memory efficiency, especially in applications with a large number of objects.

The above is the detailed content of C++ virtual function table and polymorphic implementation, how to avoid memory waste. For more information, please follow other related articles on the PHP Chinese website!