C++中如何实现多态性与性能的平衡？

夕泠爱吃糖2024-12-16 19:55

概念

在 C++ 中，实现多态性与性能的平衡是一个重要的设计问题。多态性通过虚函数和继承实现，为程序提供灵活性和可扩展性，但这通常会引入额外的开销，比如函数调用时的动态分派。因此，在设计和实现多态性时，需要考虑如何降低这种开销，同时保持系统的灵活性。

方法

使用静态多态（模板）

静态多态不依赖于运行时的动态分派，而是利用模板和编译期多态来实现。这种方法避免了虚函数的开销，同时保持了代码的灵活性。

cpp 复制代码 
#include <iostream>  

template<typename Shape>  
void drawShape(const Shape& shape) {  
    shape.draw(); // 调用自定义类型的 draw 方法  
}  

class Circle {  
public:  
    void draw() const {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

class Square {  
public:  
    void draw() const {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};  

int main() {  
    Circle circle;  
    Square square;  

    drawShape(circle); // 输出: Drawing a circle.  
    drawShape(square); // 输出: Drawing a square.  

    return 0;  
}
  • 优点
  • 无需虚函数：没有虚函数调用的开销，性能更高。
  • 类型安全：编译器在编译时检查类型，提高了安全性。

使用虚函数与优化

如果使用的是动态多态，可以通过以下方式优化虚函数的性能：

  • 减少虚函数调用的频率：在可能的情况下，尽量减少需要使用虚函数的代码部分。例如，可以将不需要频繁使用的操作封装在具体的实现类中。
  • 内联函数：将一些频繁调用的小函数声明为内联，尤其是 getters/setters 等，减少函数调用开销。
cpp 复制代码 
#include <iostream>  

class Shape {  
public:  
    virtual void draw() const {  
        std::cout << "Drawing a shape." << std::endl;  
    }  
};  

class Circle : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

class Square : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};  

void render(const Shape& shape) {  
    shape.draw(); // 虚函数调用  
}  

int main() {  
    Circle circle;  
    Square square;  

    render(circle); // 输出: Drawing a circle.  
    render(square); // 输出: Drawing a square.  

    return 0;  
}

使用对象池

如果对象的创建和销毁频繁，可以使用对象池来优化性能。这样可以重复利用对象，而不是每次都分配和释放内存，从而减少开销。

cpp 复制代码 
#include <iostream>  
#include <vector>  

// 基类 Shape  
class Shape {  
public:  
    virtual void draw() const = 0; // 纯虚函数  
    virtual ~Shape() {}              // 虚析构函数  
};  

// 派生类 Circle  
class Circle : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

// 派生类 Square  
class Square : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};  

// 对象池类 ShapePool  
class ShapePool {  
public:  
    // 构造函数，初始化对象池  
    ShapePool(size_t size) {  
        for (size_t i = 0; i < size; ++i) {  
            shapes.push_back(new Circle()); // 预分配 Circle 对象  
        }  
    }  

    // 获取对象  
    Shape* acquire() {  
        if (shapes.empty()) return nullptr; // 如果池为空，返回 nullptr  
        Shape* shape = shapes.back(); // 获取池中的最后一个对象  
        shapes.pop_back(); // 从池中移除该对象  
        return shape; // 返回该对象  
    }  

    // 释放对象  
    void release(Shape* shape) {  
        shapes.push_back(shape); // 将对象放入池中  
    }  

    // 析构函数，释放对象池中的所有对象  
    ~ShapePool() {  
        for (auto shape : shapes) {  
            delete shape; // 删除每个对象  
        }  
    }  

private:  
    std::vector<Shape*> shapes; // 维护一个对象池  
};  

int main() {  
    ShapePool pool(5); // 创建一个对象池，预分配 5 个 Circle 对象  

    Shape* shape1 = pool.acquire(); // 从对象池获取一个对象  
    if (shape1) {  
        shape1->draw(); // 输出: Drawing a circle.  
        pool.release(shape1); // 释放对象，将其放回池中  
    }  

    Shape* shape2 = pool.acquire(); // 再次从对象池获取对象  
    if (shape2) {  
        shape2->draw(); // 输出: Drawing a circle.  
        pool.release(shape2); // 释放对象  
    }  

    return 0;  
}

代码解析

1.基类和派生类

cpp 复制代码 
class Shape {  
public:  
    virtual void draw() const = 0; // 纯虚函数  
    virtual ~Shape() {}              // 虚析构函数  
};  

class Circle : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

class Square : public Shape {  
public:  
    void draw() const override {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};
  • Shape 类 是一个抽象基类，包含一个纯虚函数 draw()。它定义了 Shape 对象的基本接口，任何具体的形状类都必须实现。
  • Circle 和 Square 类 继承自 Shape，并实现了 draw() 方法。可以绘制一个圆形和一个正方形。

2.对象池类

cpp 复制代码 
class ShapePool {  
public:  
    ShapePool(size_t size) {  
        for (size_t i = 0; i < size; ++i) {  
            shapes.push_back(new Circle()); // 预分配 Circle 对象  
        }  
    }
  • ShapePool 类 是对象池的实现。
  • ShapePool(size_t size) 构造函数 接受一个参数 size，指定对象池的大小。在构造函数中，通过循环创建 Circle 对象，并将其推入 shapes 向量中。

3.获取和释放对象

cpp 复制代码 
Shape* acquire() {  
    if (shapes.empty()) return nullptr; // 如果池为空，返回 nullptr  
    Shape* shape = shapes.back(); // 获取池中的最后一个对象  
    shapes.pop_back(); // 从池中移除该对象  
    return shape; // 返回该对象  
}  

void release(Shape* shape) {  
    shapes.push_back(shape); // 将对象放入池中  
}
  • acquire() 方法 ：
    • 首先检查 shapes 向量是否为空。如果为空，则返回 nullptr，表示池没有可用对象。
    • 否则，从 shapes 向量的末尾获取一个对象，并将其移除。
  • release(Shape shape) 方法 *：
    • 接受一个指向 Shape 对象的指针，并将其推回到 shapes 向量中，使其重新成为可用对象。

4.main函数

cpp 复制代码 
int main() {  
    ShapePool pool(5); // 创建一个对象池，预分配 5 个 Circle 对象  

    Shape* shape1 = pool.acquire(); // 从对象池获取一个对象  
    if (shape1) {  
        shape1->draw(); // 输出: Drawing a circle.  
        pool.release(shape1); // 释放对象，将其放回池中  
    }  

    Shape* shape2 = pool.acquire(); // 再次从对象池获取对象  
    if (shape2) {  
        shape2->draw(); // 输出: Drawing a circle.  
        pool.release(shape2); // 释放对象  
    }  

    return 0;  
}
  • 在 main() 函数中，通过 ShapePool pool(5) 创建一个对象池，并预分配 5 个 Circle 对象。
  • 首先调用 acquire() 方法获取一个对象 shape1，然后调用 draw() 方法并输出绘制信息。
  • 接着调用 release(shape1) 将该对象放回对象池。
  • 同样的步骤再次执行，对另一个对象获取、使用及释放。

优势

  • 提高性能：对象池可以显著减少对象创建和销毁的开销，尤其是在大量对象频繁使用的场景中，降低了内存分配所需的时间。
  • 避免内存碎片：通过池来管理对象生命周期，提高了内存使用的连续性，减少了内存碎片的可能性。
  • 简单管理：对象池提供了集中管理对象的能力，使得对象的得失变得更可控。

使用 CRTP（Curiously Recurring Template Pattern）

CRTP 是一种利用模板的方式来实现多态，同时避免虚函数的开销。这种方法在某些情况下可以获得极高的性能。

cpp 复制代码 
#include <iostream>  

template<typename Derived>  
class Shape {  
public:  
    void draw() const {  
        static_cast<const Derived*>(this)->drawImpl();  
    }  
};  

class Circle : public Shape<Circle> {  
public:  
    void drawImpl() const {  
        std::cout << "Drawing a circle." << std::endl;  
    }  
};  

class Square : public Shape<Square> {  
public:  
    void drawImpl() const {  
        std::cout << "Drawing a square." << std::endl;  
    }  
};  

int main() {  
    Circle circle;  
    Square square;  

    circle.draw(); // 输出: Drawing a circle.  
    square.draw(); // 输出: Drawing a square.  

    return 0;  
}

总结

  • 1.使用静态多态：如模板编程，避免虚函数的运行时开销。
  • 2.减少虚函数调用：在复杂的类结构中，审慎使用虚函数，且适当地减少其调用频率。
  • 3.实现对象池：当对象频繁创建和销毁时，使用对象池以减少内存管理的开销。
  • 4.使用 CRTP：通过模板实现静态多态，从而避免虚函数的性能损耗。
相关推荐
明月醉窗台7 分钟前
C++ SQLite轻量化数据库使用总结
数据库·c++·sqlite
froginwe1110 分钟前
SQLite Truncate Table
开发语言
省身求是23 分钟前
C/C++代码性能优化技巧的书籍及资料
c语言·开发语言·c++
梦.清..34 分钟前
Java——多线程(中)
java·开发语言
TechNomad1 小时前
C++中函数的特性
c++
十五年专注C++开发1 小时前
LNK2001: virtual struct QMetaObject const 错误的解决方法和原因
开发语言·c++·qt
时光追逐者1 小时前
一款基于Fluent设计风格、现代化的WPF UI控件库
开发语言·ui·c#·.net·wpf·微软技术
LTIven2 小时前
编写php项目所需环境
开发语言·php
Kylin5242 小时前
C语言经典代码——part 30
c语言·开发语言·算法
@启智森2 小时前
【C语言】浮点数的原理、整型如何转换成浮点数
c语言·开发语言·嵌入式·float·int·浮点数
热门推荐
01量化方法怎么选？如何评估量化后的大模型LLM？02玄机平台应急响应—webshell查杀03(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明04学习STM32（6）-- STM32单片机ADC&DAC的应用05【凡人修仙传_01】散修厉飞羽是如何出师未捷身先死的！06Docker 夺命连环 15 问07HCIA-datacom数通题库和录播视频资料08怎么找小红书美食探店博主合作？09PyTorch机器学习实现液态神经网络1004 - matlab m_map地学绘图工具基础函数 - 设置网格