C++对象模型之C++额外成本

1.介绍

C++与C最大的区别，无疑在于面向对象，面向对象编程给C++带来了强大的特性和灵活性。但同时也带来了一定的运行时和编译时的开销。下面介绍C++对象模型的额外成本及其来源。

2.C++的额外成本

（1）虚函数和动态多态的成本

虚函数表（vtable）：如果一个类包含虚函数，编译器会给该类生成一个虚函数表，每个对象会包含一个指向虚函数表的指针（vptr），这会增加对象的内存开销。（一个指针额外占用8字节）

虚函数调用开销：调用虚函数时，需要通过 vptr 查找 vtable，再通过 vtable 找到具体的函数地址。这种间接调用比普通函数调用更慢。

动态绑定：虚函数支持运行时多态，但这也意味着编译器无法在编译时确定具体调用哪个函数，增加了运行时的开销。

class Base {
public:
    virtual void foo() { std::cout << "Base::foo()" << std::endl; }
};

class Derived : public Base {
public:
    void foo() override { std::cout << "Derived::foo()" << std::endl; }
};

int main() {
    Base* obj = new Derived();
    obj->foo();  // 虚函数调用，需要查找 vtable //调用的是派生类的函数
    delete obj;
    return 0;
}

（2）多重继承和虚继承的成本

多重继承：如果一个类从多个基类继承，对象中会包含每个基类的子对象。这可能导致对象内存布局复杂化，增加内存开销。

虚继承：虚继承用于解决菱形继承问题，但会引入额外的间接层（通过由虚基类指针实现），增加内存和运行时开销。

class A { int a; };
class B : virtual public A { int b; };
class C : virtual public A { int c; };
class D : public B, public C { int d; };

int main() {
    D obj;
    std::cout << "Size of D: " << sizeof(obj) << std::endl;  // 可能比预期大
    return 0;
}

（3）RTTI（运行时类型识别）成本

RTTI 允许在运行时获取对象的类型信息，但这需要编译器为每个类生成额外的类型信息，并存储在内存中。使用dynamic_cast时，还需要遍历继承链，增加了运行时开销。

内存开销：RTTI 会增加程序的内存占用，尤其是对于大型类层次结构。

class Base { virtual void foo() {} };
class Derived : public Base {};

int main() {
    Base* obj = new Derived();
    if (Derived* d = dynamic_cast<Derived*>(obj)) {
        std::cout << "Downcast successful" << std::endl;
    }
    delete obj;
    return 0;
}

（4）异常处理的成本

异常机制：C++ 的异常处理需要在运行时维护额外的栈帧信息和异常表，这会增加程序的内存和运行时开销。

性能影响：即使没有抛出异常，异常处理机制也会对性能产生一定影响，尤其是在函数调用和返回时。

void riskyFunction() {
    throw std::runtime_error("Something went wrong!");
}

int main() {
    try {
        riskyFunction();
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

（5）模版实例化成本

代码膨胀：模板会在编译时为每种类型生成独立的代码实例，这可能导致生成的目标文件体积增大。

编译时间：模板的实例化会增加编译时间，尤其是在模板代码复杂或模板参数类型较多时。

template <typename T>
class Box {
public:
    T value;
    void set(T v) { value = v; }
    T get() { return value; }
};

int main() {
    Box<int> intBox;
    Box<double> doubleBox;
    return 0;
}

（6）对象构造和析构的成本

构造函数和析构函数调用：在复杂的类层次结构中，构造和析构对象可能需要调用多个构造函数和析构函数，增加了运行时开销。

异常安全：如果构造函数抛出异常，需要确保已分配的资源被正确释放，这会增加额外的逻辑和开销。

class Resource {
public:
    Resource() { std::cout << "Resource acquired" << std::endl; }
    ~Resource() { std::cout << "Resource released" << std::endl; }
};

class Widget {
    Resource res;
public:
    Widget() { std::cout << "Widget created" << std::endl; }
    ~Widget() { std::cout << "Widget destroyed" << std::endl; }
};

int main() {
    Widget w;
    return 0;
}

（7）内联函数的潜在成本

代码膨胀：内联函数虽然减少了函数调用的开销，但会将函数体直接插入调用处，可能导致代码体积增大。

缓存不友好：过度的内联可能导致指令缓存效率降低，影响性能。

inline int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    return 0;
}

3.总结

C++对象模型的额外成本主要来自以上七部分。这些特性使C++更加灵活的同时也增加了额外的成本。因此要合理使用C++的特性。

如有错误，敬请指正！！！