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

如有錯誤，敬請指正！！！