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++的特性。
如有错误，敬请指正！！！