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++的特性。

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