C++ Big Three
首先是默認構造函數(default constructor) 的概念，默認構造函數是沒有參數或者全部參數都有默認值。不論這個構造函數是 user-defined 還是編譯器 auto-generated。 C++ Annotated Reference Manual 中告訴我們 :" default constructor 是在需要的時候被編譯器產生出來".
class Foo {public: int val; Foo *pnext};
void foo_bar()
{
Foo bar;
if(bar.val || bar.pnext)
{
// do something
}
}
在上面的程序中，正確的程序要求 Foo 有一個 default constructor，可以將它的兩個 member 初始化為0. 但這個并不是C++語法中所說的 “需要的時候”。
這里的需要是指的編譯器需要的時候，而不是程序的需要。C++ Standard 中提出 :" 如果沒有任何 user-defined constructor，那么會有一個default constructor 被隱式（implicitly）聲明出來， 一個被隱式聲明出來的 default constructor將是一個 trivial constructor。 但是，即使是有編譯器為類合成一個 default constructor， 那個constructor 也僅僅是為了執行編譯器所需的動作，而不一定滿足程序的需要。
在以下幾種情況下，編譯器會合成nontrivial default constructor：
- “帶有default constructor“ 的member class object
- ”帶有default constructor” 的Base Class
- “帶有一個 Virtual Function” 的Class
- “帶有一個 Virtual Base Class” 的Class
class String
{
public:
String(const char* cstr=0);
String(const String& str);
String& operator=(const String& str);
~String();
char* get_c_str() const { return m_data; }
private:
char m_data;
}
copy constructor（拷貝構造函數）
在程序中會有一些時候以一個 object 的內容作為另外一個 class object 的初值。
如果class沒有提供一個 explicit copy constructor時，當class object以相同class的另一個object作為初值時，其內部會以default memberwise initialization 初始化。 在一些情況下，這種初始化表現出的是 Bitwise Copy（位逐次拷貝）的行為。但在一些情況下，是編譯器會自動合成copy constructor，但合成的copy constructor只是滿足編譯器的需求，并不能滿足程序的需求。
在類中帶有指針成員變量的時候，一般都需要user-define 的 copy ctor。
inline
String::String(const String& str)
{
m_data = new char[ strlen(str.m_data) + 1 ];
strcpy(m_data, str.m_data);
}
copy assignment operator（拷貝賦值函數）
copy op= 的語意 在默認的情況下也是一個 memberwise copy。當類有bitwise copy 語義時，編譯器其實不會合成一個 copy op= 的函數。
只有在默認行為所導致的語意不安全或者不正確時，我們才需要一個user-define copy op= 的函數。
在類中帶有指針成員變量的時候，一般都需要user-define copy assignment operator。
inline
String& String::operator=(const String& str)
{
if (this == &str)
return *this;
delete[] m_data;
m_data = new char[ strlen(str.m_data) + 1 ];
strcpy(m_data, str.m_data);
return *this;
}
注意其中已一定要進行 self assignment的檢查，防止自我賦值情況下的異常情況的出現。
destructor （析構函數）
如果沒有user-defined destructor，只有在class 內含有member object(抑或是class 自己的 base class） 擁有 destructor的情況下，編譯器才會自動合成一個，否則，destructor被視為不需要。
在還有指針成員變量的類中，一般需要user-defined的析夠函數，以滿足程序的正確運行，防止內存泄漏等。
object 的聲明周期
object 可能存在于 stack和heap上。 Stack 是存在于某作用域的一塊內存空間， stack上的變量的聲明周期限于作用域內。 Heap 是由操作系統提供的一塊 global的內存空間，程序可以動態的分配其中的若干塊。
class Complex {...};
...
{
Complex c1(1,2); // c1 所占用的空間在stack上，c1 的生命周期在作用域結束后便結束，c1被稱為 auto object
Complex* p = new Complex(3); // Complex(3) 是個臨時對象，其所占用的空間是 new 從heap上分配的，并由p所指向，p本身是在stack上的
static Complex c2(1,2); // c2 是static object，其生命周期在作用域結束后仍然存在，直到整個程序結束
}
Complex c3(1,2); // c3 是global object， 其生命周期在整個程序結束之后才結束
int main()
{
}
heap object 需要注意 在指向這塊內存的變量生命周期結束前，正確的調用析夠函數，清理heap object，否則可能造成內存泄漏。如上面的 p , 如果在作用域結束前沒有 delete p，則在作用域結束后，p變量不存在了，就沒有機會去釋放 p 所指向的 heap object了，會造成內存泄漏。
new 和 delete 的內存操作
new 是先分配內存，然后再調用 ctor。
Complex* pc = new Complex(1,2);
// 上面這句話會被編譯器轉化為
Complex* pc;
void* mem = operator new(sizeof(Complex)); // 分配內存
pc = static_cast<Complex*>(mem); // 轉型
pc->Complex::Complex(1,2); // 調用構造函數
delete 是先調用 dtor， 然后再釋放內存
Complex* pc = new Complex(1,2);
...
delete pc;
// 上面 delete pc 會被轉化為
Complex::~Complex(pc); // 調用析夠函數
operator delete(pc); // 釋放內存
同時 array new 一定要搭配 array delete
String* p = new String[3];
...
delete[] p; // 調用3次 dtor
static
static可以用來修飾成員變量和成員函數。
static成員函數沒有默認的this指針。
調用stati函數的方式有二：
- 通過object調用
- 通過class name調用
Sigleton 模式
通過將 ctor 放在 private 區域，可以實現Signleton的模式。
class A {
public:
static A& getInstance();
setup();
private:
A();
A(const A& rhs);
...
};
A& A::getInstatnce()
{
static A a;
return a;
}
C++11 中增加了delete關鍵字也可以達到將 copy constructor 放在private 中相同的效果。
