前言

當定義一個類時，我們顯式或隱式地指定在此類型的對象拷貝、移動、賦值和銷毀時做什么。一個類通過定義五種特殊的成員函數來控制這些操作，包括：拷貝構造函數、拷貝賦值運算符、移動構造函數、移動賦值運算符和析構函數。拷貝和移動構造函數定義了當用同類型的另一個對象初始化本對象時做什么。拷貝和移動賦值運算符定義了將一個對象賦予同類型的另一個對象時做什么。析構函數定義了當此類型對象銷毀時做什么。我們稱這些操作為拷貝控制操作。

在定義任何c++類時，拷貝控制操作都是必要部分。必須定義對象拷貝、移動、賦值或銷毀時做什么。如果我們不顯式定義這些操作，編譯器也會為我們定義，但編譯器定義的版本的行為可能并非我們所想。

拷貝、賦值與銷毀

拷貝構造函數

如果一個構造函數的第一個參數是自身類類型的引用，且任何額外參數都有默認值，則此構造函數是拷貝構造函數：

class Foo{Foo();//默認構造函數Foo(const Foo&); //拷貝構造函數
}

雖然我們可以定義一個接受非const引用的拷貝構造函數，但此參數幾乎總是一個const的引用。拷貝構造函數在幾種情況下都會被隱式地使用。因此拷貝構造函數通常不應該是explicit的。
拷貝構造函數的第一個參數必須是一個引用類型的原因在這里。

合成拷貝構造函數

如果我們沒有為一個類定義拷貝構造函數，編譯器會為我們定義一個。與合成默認構造函數不同，即使我們定義了其他構造函數，編譯器也會為我們合成一個拷貝構造函數。

一般情況下，合成的拷貝構造函數會將其參數的成員逐個拷貝到正在創建的對象中。編譯器從給定對象中依次將每個非static成員拷貝到正在創建的對象中。對內置類型的成員，直接進行內存拷貝，對類類型的成員，調用其拷貝構造函數進行拷貝。

拷貝初始化和直接初始化

當使用直接初始化時，我們實際上是要求編譯器使用普通的函數匹配來選擇與我們提供的參數最匹配的構造函數。當我們使用拷貝初始化時，我們要求編譯器將右側運算對象拷貝到正在創建的對象中，如果需要的話還要進行類型轉換。

拷貝初始化的發生：

• 用 = 定義變量時
• 將一個對象作為實參傳遞給一個非引用類型的形參
• 從一個返回類型為非引用類型的函數返回一個對象
• 用花括號列表初始化一個數組中的元素或一個聚合類中的成員
• 初始化標準庫容器或調用其insert/push操作時，容器會對其元素進行拷貝初始化

參數和返回值

在函數調用過程中，具有非引用類型的參數要進行拷貝初始化。類似的，當一個函數具有非引用的返回類型時，返回值會被用來初始化調用方的結果。

拷貝構造函數的第一個參數必須是一個引用類型的原因：
拷貝構造函數被用來初始化非引用類類型參數。如果拷貝構造函數自己的參數不是引用類型，則調用永遠也不會成功——為了調用拷貝構造函數，我們必須拷貝它的實參，但為了拷貝實參，我們又需要調用拷貝構造函數，如此無限循環。

拷貝初始化的限制

如前所述，如果我們使用的初始化值要求通過一個explicit的構造函數來進行類型轉換，那么使用拷貝初始化還是直接初始化就不是無關緊要的了：

拷貝賦值運算符

與類控制其對象如何初始化一樣，類也可以控制其對象如何賦值：

Sales_data trans,accum;
trans = accum; //使用Sales_data的拷貝賦值運算符

與拷貝構造函數一樣，如果類未定義自己的拷貝賦值運算符，編譯器會為它合成一個。

重載賦值運算符

重載運算符本質上是函數，其名字由operator關鍵字后接表示要定義的運算符的符號組成。因此賦值運算符就是一個名為 operator= 的函數，類似于任何其他函數，運算符函數也有一個返回類型和一個參數列表。

重載運算符的參數表示運算符的運算對象。某些運算符，包括賦值運算符，必須定義為成員函數。如果一個運算符是一個成員函數，其左側運算對象就綁定到隱式的this參數。對于一個二元運算符，例如賦值運算符，其右側運算對象作為顯式參數傳遞。

為了與內置類型的賦值保持一致，賦值運算符通常返回一個指向其左側運算對象的引用。另外，標準庫通常要求保存在容器中的類型要具有賦值運算符，且其返回值是左側運算對象的引用。

賦值運算符通常應該返回一個指向其左側運算對象的引用。

合成拷貝賦值運算符

與處理拷貝構造函數一樣，如果一個類未定義自己的拷貝賦值運算符，編譯器會為它生成一個合成拷貝賦值運算符。

通常情況下，合成的拷貝賦值運算符會將右側對象的非static成員逐個賦予左側對象的對應成員，這些賦值操作是由成員類型的拷貝賦值運算符來完成的。

析構函數

析構函數執行與構造函數相反的操作：構造函數初始化對象的非static數據成員，還可能做一些其他工作；析構函數釋放對象使用的資源，并銷毀對象的非static數據成員。

析構函數沒有返回值，也不接受參數：

class Foo{
public:~Foo();//析構函數
}

由于析構函數不接受參數，因此它不能被重載。對一個給定類，只會有唯一一個析構函數。

析構函數完成的工作

在一個構造函數中，成員的初始化是在函數體執行之前完成的，且按照它們在類中出現的順序進行初始化。在一個析構函數中，首先執行函數體，然后銷毀成員。成員按初始化順序的逆序銷毀。

在一個析構函數中，不存在類似構造函數中初始化列表的東西來控制成員如何銷毀，析構部分是隱式的。成員銷毀時發生什么完全依賴于成員的類型。銷毀類類型的成員需要執行成員自己的析構函數。內置類型沒有析構函數，因此銷毀內置類型成員什么也不需要做。

隱式銷毀一個內置指針類型的成員不會delete它所指向的對象。

與普通指針不同，智能指針是類類型，所以具有析構函數。因此與普通指針不同，智能指針成員在析構階段會被自動銷毀。

什么時候會調用析構函數

無論何時一個對象被銷毀，就會自動調用其析構函數

• 變量在離開其作用域時被銷毀
• 當一個對象被銷毀時，其成員被銷毀
• 容器（無論是標準庫容器還是數組）被銷毀時，其元素被銷毀
• 對于動態分配的對象，當對指向它的指針應用delete運算符時被銷毀
• 對于臨時對象，當創建它的完整表達式結束時被銷毀

由于析構函數自動運行，我們的程序可以按需分配資源，無需擔心何時釋放這些資源。

當指向一個對象的引用或指針離開作用域時，析構函數不會執行。

合成析構函數

當一個類未定義自己的析構函數時，編譯器會為它定義一個合成析構函數。

析構函數體自身并不直接銷毀成員。成員是在析構函數體之后隱含的析構階段中被銷毀的。在整個對象銷毀過程中，析構函數體是作為成員銷毀步驟之外的另一部分而進行的。

代碼片段調用幾次析構函數

代碼一：指針 調用3次

bool fcn(const Sales_data *trans,Sales_data accum){Sales_data item1(*trans),item2(accum);return item1.isbn()!=item2.isbn();
}

測試：

	Sales_data s(string("001"),10,5);Sales_data s2(string("001"), 10, 5);Sales_data *s1=&s;fcn(s1,s2);

其中析構函數為：

~Sales_data() { cout << "這是在執行Sales_data的析構函數..." << endl; }

輸出結果：

這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...

調用三次析構函數：

• 函數結束時，局部變量item1和item2的生命期結束，被銷毀，Sales_data的析構函數被調用
• 函數結束時，參數accum的生命期結束，被銷毀，Sales_data的析構函數被調用
• 在函數結束時，trans的生命期也結束了，但它是Sales_data的指針，并不是它指向的Sales_data對象的生命期結束（只有delete指針時，指向的動態對象的生命期才結束）

代碼二：引用 調用3次

bool fcn(const Sales_data &trans, Sales_data accum) {Sales_data item1(trans), item2(accum);return item1.isbn() != item2.isbn();
}

輸出結果：

這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...

代碼三：調用4次

bool fcn(const Sales_data &trans, Sales_data accum) {Sales_data item1(trans), item2(accum);return item1.isbn() != item2.isbn();
}

輸出結果：

這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...
這是在執行Sales_data的析構函數...

根據代碼理解 拷貝構造函數、拷貝賦值運算符以及析構函數何時執行

Y類

class Y {Y() { cout << "構造函數Y()" << endl; }Y(const Y&) { cout << "拷貝構造函數Y(const Y&)" << endl; }Y& operator=(const Y&rhs) { cout << "拷貝賦值運算符=(const Y&)" << endl; return *this; }~Y() { cout << "析構函數~Y()" << endl; }
};

測試代碼：

void f1(Y y){}
void f2(Y& y) {}
void testY() {cout << "局部變量：" << endl;Y y;cout << endl;cout << "非引用參數傳遞：" << endl;f1(y);cout << endl;cout << "引用參數傳遞：" << endl;f2(y);cout << endl;cout << "動態分配：" << endl;Y *py = new Y;cout << endl;cout << "添加到容器中：" << endl;vector<Y>vy;vy.push_back(y);cout << endl;cout << "釋放動態分配對象：" << endl;delete py;cout << endl;cout << "間接初始化和賦值：" << endl;Y tmp = y;tmp = y;cout << endl;cout << "程序結束；" << endl;
}

輸出結果：

局部變量：
構造函數Y()非引用參數傳遞：
拷貝構造函數Y(const Y&)
析構函數~Y()引用參數傳遞：動態分配：
構造函數Y()添加到容器中：
拷貝構造函數Y(const Y&)釋放動態分配對象：
析構函數~Y()間接初始化和賦值：
拷貝構造函數Y(const Y&)
拷貝賦值運算符=(const Y&)程序結束；
析構函數~Y()
析構函數~Y()
析構函數~Y()

程序結束后的三次Y的析構函數分別是tmp，vector中的元素和y
編譯器可以略過對拷貝構造函數的調用。

三 / 五法則

有三個基本操作可以控制類的拷貝操作：拷貝構造函數、拷貝賦值運算符和析構函數。而且，在新標準下，一個類還可以定義一個移動構造函數和一個移動賦值運算符。
C++語言并不要求我們定義所有這些操作，可以只定義其中一個或兩個，而不必定義所有。但是，這些操作通常應該被看做一個整體。通常，只需要其中一個操作，而不需要定義所有操作的情況是很少見的。

需要析構函數的類也需要拷貝和賦值操作

當我們決定一個類是否有必要定義它自己版本的拷貝控制成員時，一個基本原則是首先確定這個類是否需要一個析構函數。通常，對析構函數的需求要比對拷貝構造函數或賦值運算符的需求更為明顯。如果這個類需要一個析構函數，我們幾乎可以肯定它也需要一個拷貝構造函數和一個拷貝賦值運算符。

示例代碼

如果我們為HasPtr定義一個析構函數，但使用合成版本的拷貝構造函數和拷貝賦值運算符：

class HasPtr{
public:HasPtr(const string &s=string()):ps(new string(s)),i(0){}~HasPtr(){delete ps;}
private:string *ps;int i;
}HasPtr foo(HasPtr hp){HasPtr ret = hp;return ret;
}

在該示例中，當foo運行完畢后，hp和ret都會被銷毀，在兩個對象上都會調用HasPtr的析構函數，此析構函數會delete ret和hp中的指針成員，但這兩個對象包含相同的指針值（因為合成的拷貝構造函數和拷貝賦值運算符，只是簡單的拷貝指針成員，因此ret和hp中的指針成員指向相同的內存），此代碼會導致此指針值被delete兩次，這顯然是一個錯誤。

因此，如果一個類需要自定義析構函數，幾乎可以肯定它也需要自定義拷貝賦值運算符和拷貝構造函數。

需要拷貝操作的類也需要賦值操作，反之亦然

需要拷貝操作的類也需要賦值操作，反之亦然。然而無論是需要拷貝構造函數還是需要拷貝賦值運算符都不必然意味著也需要析構函數。

示例代碼

沒有拷貝構造的類

class Numbered {public:Numbered() { mysn = num++; }int mysn;
private:static int num;
};
int Numbered::num = 0;

無論 f 函數是值傳遞還是引用傳遞結果均為0 0 0 0

void f(Numbered &n) {cout << "n:" << n.mysn << endl;
}
void testNumbered() {Numbered n,n2=n;cout << "n:" << n.mysn << endl;cout << "n2:" << n2.mysn << endl;cout << "f(n): " << endl;f(n);cout << "f(n2): " << endl;f(n2);
}

輸出結果：

n:0
n2:0
f(n):
n:0
f(n2):
n:0

有拷貝構造的類

class Numbered {public:Numbered() { mysn = num++; }Numbered(Numbered&n) { mysn = num++; }int mysn;
private:static int num;
};
int Numbered::num = 0;

參數是值傳遞，在傳參的過程中，又進行了拷貝構造，故輸出結果為0 1 2 3

void f(Numbered n) {cout << "n:" << n.mysn << endl;
}
void testNumbered() {Numbered n,n2=n;cout << "n:" << n.mysn << endl;cout << "n2:" << n2.mysn << endl;cout << "f(n): " << endl;f(n);cout << "f(n2): " << endl;f(n2);
}

輸出結果：

n:0
n2:1
f(n):
n:2
f(n2):
n:3

參數是引用傳遞：

void f(Numbered &n) {cout << "n:" << n.mysn << endl;
}
void testNumbered() {Numbered n,n2=n;cout << "n:" << n.mysn << endl;cout << "n2:" << n2.mysn << endl;cout << "f(n): " << endl;f(n);cout << "f(n2): " << endl;f(n2);
}

輸出結果：

n:0
n2:1
f(n):
n:0
f(n2):
n:1

=default

我們可以通過將拷貝控制成員定義為 =default 來顯式地要求編譯器生成合成的版本。

我們只能對具有合成版本的成員函數使用 =default （即，默認構造函數或拷貝控制成員）

阻止拷貝

大多數類應該定義默認構造函數、拷貝構造函數和拷貝賦值運算符，無論是隱式地還是顯式地。但對某些類來說，這些操作沒有合理的意義。在此情況下，定義類時必須采用某種機制阻止拷貝或賦值。例如，iostream類阻止了拷貝，以避免多個對象寫入或讀取相同的IO緩沖。如果我們不定義拷貝控制成員，編譯器依然會為它生成合成的版本，因此這種策略不能避免類的拷貝。

定義刪除的函數

我們可以通過將拷貝構造函數和拷貝賦值運算符定義為刪除的函數來阻止拷貝。 刪除的函數是這樣一種函數：我們雖然生命了它們，但不能以任何方式使用它們。在函數的參數列表后面加上 =delete 來指出我們希望將它定義為刪除的

class Nocopy{Nocopy() = default;//使用合成的默認構造函數Nocopy(const Nocopy&)=delete;//阻止拷貝Nocopy &operator=(const Nocopy&)=delete;//阻止賦值~Nocopy() = default;//使用合成的析構函數
};

與 =default 不同，=delete 必須出現在函數第一次聲明的時候。此外，我們可以對任何函數指定 =delete（我們只能對編譯器可以合成的默認構造函數或拷貝控制成員使用 =default）。雖然刪除函數的主要用途是禁止拷貝控制成員，但當我們希望引導函數匹配過程時，刪除函數有時也是有用的。

析構函數不能是刪除函數的成員

值得注意的是，我們不能刪除析構函數。因為如果析構函數被刪除，就無法銷毀此類型的對象了。對于一個刪除了析構函數的類型，編譯器將不允許定義該類型的變量或創建該類的臨時變量。

對于刪除了析構函數的類型，雖然我們不能定義這種類型的變量或成員，但可以動態分配這種類型的對象，但是不能釋放指向該類型動態分配對象的指針。

合成的拷貝控制成員可能是刪除的

如果一個類未定義拷貝控制成員或構造函數，編譯器會定義默認的合成版本。對某些類來說，編譯器將這些合成的成員定義為刪除的函數：

• 如果類的某個成員的析構函數是刪除的或不可訪問的，則類的合成析構函數被定義為刪除的
• 如果類的某個成員的拷貝構造函數是刪除的或不可訪問的，則類的合成拷貝構造函數被定義為刪除的。如果類的某個成員的析構函數是刪除的或不可訪問的，則類的合成拷貝構造函數被定義為刪除的。
• 如果類的某個成員的拷貝賦值運算符是刪除的或不可訪問的，或是類有一個const的或引用成員，則類的合成拷貝賦值運算符被定義為刪除的。
• 如果類的某個成員的析構函數是刪除的或不可訪問的，或是類有一個引用成員，它沒有類內初始化器，或是類有一個const成員，它沒有類內初始化器且其類型未顯式定義默認構造函數，則類的默認構造函數被定義為刪除的

本質上，這些規則的含義是：如果一個類有數據成員不能默認構造、拷貝、復制或銷毀，則對應的成員函數將被定義為刪除的。

拷貝控制和資源管理

通常，管理類外資源的類必須定義拷貝控制成員，這種類需要通過析構函數來釋放對象所分配的資源。一旦一個類需要析構函數，那么它幾乎肯定也需要一個拷貝構造函數和一個拷貝賦值運算符。

為了定義這些成員，我們首先必須確定此類型對象的拷貝語義。一般來說，有兩種選擇：可以定義拷貝操作，使類的行為看起來像一個值或者像一個指針。

類的行為像一個值，意味著它應該也有自己的狀態。當我們拷貝一個像值的對象時，副本和原對象是完全獨立的。改變副本不會對原對象有任何影響，反之亦然。

行為像指針的類則共享狀態。當我們拷貝一個這種類的對象時，副本和原對象使用相同的底層數據。改變副本也會改變原對象，反之亦然。

標準庫容器和string類的行為像一個值。shared_ptr類提供類似指針的行為。IO類型和unique_ptr不允許拷貝或賦值，因此它們的行為既不像值也不像指針。

行為像值的類

為了提供類值的行為，對于類管理的資源，每個對象都應該擁有一份自己的拷貝。這意味著對于ps指向的string，每個HasPtr對象都必須有自己的拷貝。為了實現類值行為，HasPtr需要：

• 定義一個拷貝構造函數，完成string的拷貝，而不是拷貝指針
• 定義一個析構函數來釋放string
• 定義一個拷貝賦值運算符來釋放對象當前的string，并從右側運算對象拷貝string

示例代碼

類值版本的HasPtr如下所示：

class HasPtr{
public:HasPtr(const string &s=string()):ps(new string(s)),i(0){}HasPtr(const HasPtr &p):ps(new string(*p.ps)),i(p.i){}HasPtr& operator=(const HasPtr &);~HasPtr(){delete ps;}
private:string *ps;int i;
}

此處要注意，HasPtr(const HasPtr &p):ps(new string(*p.ps)),i(p.i){}為什么拷貝構造函數的參數可以直接去訪問它自己的私有成員?
對象能否訪問到私有成員與其定義的位置有關：在類內定義，可以訪問，在類外定義，不能訪問。在類的成員函數中可以訪問同類型實例對象的私有成員變量。

類值拷貝賦值運算符

賦值運算符通常組合了析構函數和構造函數的操作。類似析構函數， 賦值操作會銷毀左側運算對象的資源。類似拷貝構造函數，賦值操作會從右側運算對象拷貝數據。這些操作是以正確的順序執行的，即使將一個對象賦予它自身，也保證正確。而且，如果可能，我們編寫的賦值運算符還應該是異常安全的——當異常發生時能將左側運算對象置于一個有意義的狀態。

HasPtr& HasPtr::operator=(const HasPtr &rhs){auto newp = new string(*rhs.ps);//拷貝底層stringdelete ps;//釋放舊內存ps=newp;//從右側運算對象拷貝數據到本對象i=rhs.i;return *this;//返回本對象
}

當編寫賦值運算符時，有兩點需要記住：

• 如果將一個對象賦予它自身，賦值運算符必須能正確工作。
• 大多數賦值運算符組合了析構函數和拷貝構造函數的工作。

當編寫一個賦值運算符時，一個好的模式是先將右側運算對象拷貝到一個局部臨時對象中。當拷貝完成后，銷毀左側運算對象的現有成員就是安全的了。一旦左側運算對象的資源被銷毀，就只剩下將數據從臨時對象拷貝到左側運算對象的成員中了。

定義行為像指針的類

對于行為類似指針的類，我們需要為其定義拷貝構造函數和拷貝賦值運算符，來拷貝指針成員本身而不是它指向的string。我們的類仍然需要自己的析構函數來釋放接受string參數的構造函數分配的內存。只有當最后一個指向string的HasPtr銷毀時，它才可以釋放string。

令一個類展現類似指針的行為的最好方法是使用shared_ptr來管理類中的資源。

但是，有時我們希望直接管理資源，在這種情況下我們可以使用引用計數。引用計數的工作方式如下：

• 除了初始化對象外，每個構造函數（拷貝構造函數除外）還要創建一個引用計數，用來記錄有多少對象與正在創建的對象共享狀態。當我們創建一個對象時，只有一個對象共享狀態，因此將計數器初始化為1。
• 拷貝構造函數不分配新的計數器，而是拷貝給定對象的數據成員，包括計數器。拷貝構造函數遞增共享的計數器，指出給定對象的狀態又被一個新用戶所共享。
• 析構函數遞減計數器，指出共享狀態的用戶少了一個。如果計數器變為0，則析構函數釋放狀態。
• 拷貝賦值運算符遞增右側運算對象的計數器，遞減左側運算對象的計數器。如果左側運算對象的計數器變為0，意味著它的共享狀態沒有用戶了，拷貝賦值運算符就必須銷毀狀態。

我們將計數器保存在動態內存中，當創建一個對象時，我們也分配一個新的計數器。當拷貝或賦值對象時，我們拷貝指向計數器的指針。使用這種方法，副本和原對象都會指向相同的計數器。

示例代碼

class HasPtr {
public://構造函數分配新的string和新的計數器，將計數器置為1HasPtr(const string &s = string()) :ps(new string(s)), i(0),use(new size_t(1)) {}//拷貝構造函數拷貝所有三個數據成員，并遞增計數器HasPtr(const HasPtr &p) :ps(p.ps), i(p.i), use(p.use) { ++*use; }//賦值運算符HasPtr& operator=(const HasPtr &rhs) {++*rhs.use;//遞增右側運算對象的引用計數if (--*use == 0) { //遞減本對象的引用計數，delete ps;	  //如果計數為0，則釋放本對象分配的成員delete use;}ps = rhs.ps;  //將數據從rhs拷貝到本對象i = rhs.i;use = rhs.use;return *this;  //返回本對象}//析構函數~HasPtr() {//如果引用計數變為0，則釋放string內存，釋放計數器內存if (--*use == 0) {delete ps;delete use;}}//打印usevoid printUse() { cout << "use:" << *use << endl; }
private:string *ps;int i;size_t *use;
};

測試代碼：

	HasPtr hp1("hello");hp1.printUse();  //1HasPtr hp2(hp1);hp1.printUse();  //2hp2.printUse();  //2HasPtr hp3;HasPtr hp4(hp3);hp3.printUse();  //2hp4.printUse();  //2hp4 = hp1;//增加 hp1 的計數，減少hp4原計數器的計數，賦值操作后，hp4和hp1指向相同的內存，故hp3計數為1，其余計數為3hp1.printUse(); //3hp2.printUse(); //3hp3.printUse(); //1hp4.printUse(); //3

交換操作

除了定義拷貝控制成員，管理資源的類通常還定義一個名為swap的函數。

如果一個類定義了自己的swap，那么算法將使用類自定義版本。否則，算法將使用標準庫定義的swap。雖然與往常一樣我們不知道swap是如何實現的，但理論上很容易理解，為了交換兩個對象我們需要進行一次拷貝和兩次賦值。

定義swap的類通常用swap來定義它們的賦值運算符。這些運算符使用了一種名為拷貝并交換的技術。這種技術將左側運算對象與右側運算對象的一個副本進行交換。（在這個版本的賦值運算符中，參數并不是一個引用，因此rhs是右側運算對象的一個副本）

//rhs是按值傳遞的，意味著HasPtr的拷貝構造函數
//將右側運算對象中的string拷貝到rhs
HasPtr& HasPtr::operator=(HasPtr rhs){//交換左側運算對象和局部變量rhs的內容swap(*this,rhs); //rhs現在指向本對象曾經使用的內存return *this;  //rhs被銷毀，從而delete了rhs中的指針
}

拷貝控制示例

雖然通常來說，分配資源的類更需要拷貝控制，但資源管理并不是一個類需要定義自己的拷貝控制成員的唯一原因。一些類也需要拷貝控制成員的幫助來進行簿記工作或其他操作。

示例代碼【兩個類相互調用】

我們定義Message和Folder類，為了記錄Message位于哪些Folder中，每個Message都會保存一個它所在Folder的指針的set集合，同樣的，每個Folder都保存一個它包含的Message的指針的set集合。

Message類：
Message.h文件

#ifndef __MESSAGE__
#define __MESSAGE__#include<iostream>
#include<set>
#include<string>
#include"Folder.h"
using namespace std;class Message {friend class Folder;
public:explicit Message(const string &str="") :contents(str){}Message(const Message&);//拷貝構造函數Message& operator=(const Message&);//拷貝賦值運算符~Message();//析構函數//從給定Folder集合中添加/刪除本Messagevoid save(Folder&);void remove(Folder&);void addFldr(Folder *f) {folders.insert(f);}private:string contents; //實際消息文本set<Folder*>folders; //包含本Message的Folder//工具函數//將本Message添加到指向參數的Folder中void add_to_Folders(const Message&);//從folders中的每個Folder中刪除Messagevoid remove_from_Folders();
};
#endif

Message.cpp文件

#include"Folder.h"
#include"Message.h"void Message::save(Folder &f) {folders.insert(&f);//將給定Folder添加到我們的Folder列表中f.addMsg(this); //將本Message添加到f的Message集合中
}
void Message::remove(Folder &f) {folders.erase(&f);//將給定Folder從我們的Folder列表中移除f.remMsg(this);  //將本Message從f的Message集合中移除
}//工具函數
//將本Message添加到指向m的Folder中
void Message::add_to_Folders(const Message&m) {for (auto f : m.folders) {f->addMsg(this);}
}
Message::Message(const Message&m) :contents(m.contents), folders(m.folders) {add_to_Folders(m);
}
//從對應的Folder中刪除本Message
void Message::remove_from_Folders() {for (auto f : folders)f->remMsg(this);
}
Message::~Message() {remove_from_Folders();
}
//我們先從左側運算對象的folders中刪除此Message的指針，
//然后再將指針添加到右側運算對象的folders中，
//從而實現了自賦值的正確處理
Message& Message::operator=(const Message&rhs) {remove_from_Folders();contents = rhs.contents;folders = rhs.folders;add_to_Folders(rhs);return *this;
}

Folder類：
Folder.h文件

#ifndef __FOLDER__
#define __FOLDER__#include<iostream>
#include<set>
#include<string>
using namespace std;class Message;
class Folder {
public:Folder() {}Folder(const Folder &f) :message(f.message) { add_to_message(f); }Folder& operator=(const Folder&f) {remove_from_message();message = f.message;add_to_message(f);return *this;}~Folder() {remove_from_message();}void addMsg(Message *m) {message.insert(m);}void remMsg(Message *m) {message.erase(m);}void printMsg();
private:set<Message*>message;void add_to_message(const Folder &f);void remove_from_message();
};
#endif

Folder.cpp文件

#include"Folder.h"
#include"Message.h"void Folder::add_to_message(const Folder &f) {for (auto msg : f.message) {msg->addFldr(this);}
}void Folder::remove_from_message() {while (!message.empty()) {(*message.begin())->remove(*this);}
}void Folder::printMsg() {for (auto m : message) {cout << "message.contents: " << (*m).contents << endl;}
}

測試函數：

	Message m1("hello,m1");Folder f1,f2,f3,f4;m1.save(f1);m1.save(f3);Message m2("hello,m2");m2.save(f1);m2.save(f2);m2.save(f4);Message m3("hello,m3");m3.save(f2);m3.save(f3);m3.save(f4);cout << "f1:" << endl;f1.printMsg();cout << "f2:" << endl;f2.printMsg();cout << "f3:" << endl;f3.printMsg();cout << "f4:" << endl;f4.printMsg();m1.remove(f1);m2.remove(f2);m3.remove(f3);cout << "f1:" << endl;f1.printMsg();cout << "f2:" << endl;f2.printMsg();cout << "f3:" << endl;f3.printMsg();cout << "f4:" << endl;f4.printMsg();

輸出結果：

f1:
message.contents: hello,m2
message.contents: hello,m1
f2:
message.contents: hello,m3
message.contents: hello,m2
f3:
message.contents: hello,m3
message.contents: hello,m1
f4:
message.contents: hello,m3
message.contents: hello,m2
f1:
message.contents: hello,m2
f2:
message.contents: hello,m3
f3:
message.contents: hello,m1
f4:
message.contents: hello,m3
message.contents: hello,m2

本測試代碼起初有報錯，原因是將h文件和cpp文件均寫到了h文件中，后來將二者分開（即，成員聲明和定義分離即可） 程序即可以運行了。此處可參見某博客鏈接。

動態內存管理類

某些類需要在運行時分配可變大小的內存空間。這種類通常可以使用標準庫容器來存放它們的數據。這種類通常可以（并且如果它們確實可以的話，一般應該）使用標準庫容器來保存它們的數據。

如果某些類需要自己進行內存分配，這些類一般來說必須定義自己的拷貝控制成員來管理所分配的內存。

StrVec類的設計

我們實現標準庫vector類的一個簡化版本，即不使用模板，只用于string。

vector類將其元素保存在連續內存中。為了獲得可接受的性能，vector預先分配足夠的內存來保存可能需要的更多元素。vector的每個添加元素的成員函數會檢查是否有空間容納更多的元素。如果有，成員函數會在下一個可用位置構造一個新對象。如果沒有可用空間，vector就會重新分配空間：它獲得新的空間，將已有元素移動到新空間中，釋放舊空間，并添加新元素。

reallocate成員函數

移動構造函數

通過使用標準庫引入的兩種機制，我們就可以避免string的拷貝。有一些標準庫類，包括string，都定義了所謂的“移動構造函數”，移動構造函數通常是將資源從給定對象“移動”而不是拷貝到正在創建的對象。

std::move

標準庫函數move，定義在utility頭文件中。關于move，我們需要了解兩個關鍵點，首先，當reallocate在新內存中構造string時，它必須調用move來表示希望使用string的移動構造函數。如果它漏掉了move調用，將會使用string的拷貝構造函數。其次，我們通常不為move提供一個using聲明，當我們使用move時，直接調用std::move而不是move

StrVec代碼

StrVeC類：

#ifndef STRVEC_H
#define STRVEC_H#include<iostream>
#include<memory>
#include <string>
using namespace std;class StrVec
{
public:StrVec():elements(nullptr),first_free(nullptr),cap(nullptr) {};StrVec(const StrVec&);//拷貝構造函數StrVec &operator=(const StrVec&);//拷貝賦值運算符~StrVec();//析構函數void push_back(const string&);//拷貝元素size_t size()const { return first_free - elements; }size_t capacity()const { return cap - elements; }string * begin()const { return elements; }string * end()const { return first_free; }
private:allocator<string> alloc;//被添加元素的函數使用void chk_n_alloc() {if (size() == capacity())reallocate();}//工具函數，被拷貝構造函數、賦值運算符和析構函數所使用pair<string*, string*> alloc_n_copy(const string*,const string*);void free();//銷毀元素并釋放內存void reallocate();//獲得更多內存并拷貝已有元素string * elements;//指向數組首元素的指針string * first_free;//指向數組第一個空閑元素的指針string * cap;//指向數組尾后位置的指針
};void StrVec::push_back(const string&s) {chk_n_alloc();alloc.construct(first_free++,s);
}//此函數返回一個指針的pair，兩個指針分別指向新空間的開始位置和拷貝的尾后的位置pair<string*, string*> StrVec::alloc_n_copy(const string*b, const string*e) {//分配空間保存給定范圍中的元素auto data = alloc.allocate(e-b);//初始化并返回一個pair，該pair由data和uninitialized_copy的返回值構成auto end = uninitialized_copy(b, e, data);return{ data, end};
}
void StrVec::free() {if (elements) {for (auto ptr = first_free;ptr != elements;) {alloc.destroy(--ptr);}alloc.deallocate(elements, cap-elements);}	
}StrVec::StrVec(const StrVec&s) {pair<string*, string*>p=alloc_n_copy(s.begin(),s.end());elements = p.first;first_free = p.second;cap = p.second;
}
StrVec::~StrVec() {free();
}
StrVec & StrVec::operator=(const StrVec&rhs) {pair<string*, string*>p = alloc_n_copy(rhs.begin(), rhs.end());free();elements = p.first;first_free = p.second;cap = p.second;return *this;
}
//reallocate函數
//為一個新的更大的string數組分配內存
//在內存空間的前一部分構造對象，保存現有元素
//銷毀原內存空間中的元素，并釋放這塊內存
void StrVec::reallocate() {//我們將分配當前大小兩倍的內存空間auto newcapacity = size() ? 2 * size() : 1;//分配新內存auto newdata = alloc.allocate(newcapacity);//將數據從舊內存移動到新內存auto dest = newdata;//指向新數組中下一個空閑位置auto elem = elements;//指向舊數組中下一個元素for (size_t i = 0;i != size();++i) {alloc.construct(dest++,std::move(*elem++));}free();//一旦我們移動完元素就釋放舊內存空間//更新我們的數據結構，執行新元素elements = newdata;first_free = dest;cap = elements + newcapacity;
}
#endif 

測試代碼：

void printSize(StrVec &s) {cout << "size(): " << s.size() << endl;cout << "capacity(): " << s.capacity() << endl;cout << endl;
}
void testStrVec() {StrVec s;printSize(s);for (int i = 0;i <10;i++) {s.push_back(to_string(i));printSize(s);}for (auto beg = s.begin();beg != s.end();beg++) {cout << *beg<<" ";}}int main() {testStrVec();	system("pause");return 0;
}

輸出結果：從輸出結果可以看出，當進行push_back操作時，若沒有空間添加新元素，則將分配當前大小兩倍的內存空間

size(): 0
capacity(): 0size(): 1
capacity(): 1size(): 2
capacity(): 2size(): 3
capacity(): 4size(): 4
capacity(): 4size(): 5
capacity(): 8size(): 6
capacity(): 8size(): 7
capacity(): 8size(): 8
capacity(): 8size(): 9
capacity(): 16size(): 10
capacity(): 160 1 2 3 4 5 6 7 8 9 

對象移動

新標準的一個最主要的特性是可以移動而非拷貝對象的能力。在某些情況下，對象拷貝后就立即被銷毀了，此時移動而非拷貝對象會大幅度提升性能。

標準庫容器、string和shared_ptr類既支持移動也支持拷貝。IO類和unique_ptr類可以移動但不能拷貝。

右值引用

為了支持移動操作，新標準引入了一種新的引用類型——右值引用。所謂右值引用就是必須綁定到右值的引用。我們通過&&而不是&來獲得右值引用。右值引用有一個重要的性質——只能綁定到一個將要銷毀的對象。因此我們可以自由地將一個右值引用的資源“移動”到另一個對象中。

一般而言，一個左值表達式表示的是一個對象的身份，而一個右值表達式表示的是對象的值。

類似任何引用，一個右值引用也不過是某個對象的另一個名字而已。對于常規引用（為了區別右值引用，我們可稱之為左值引用），我們不能將其綁定到要求轉換的表達式、字面常量或是返回右值的表達式。右值引用有著完全相反的綁定特性：我們可以將一個右值引用綁定到這類表達式上，但不能將一個右值引用直接綁定到一個左值上。

int i=42;
int &r=i;  //正確：r引用i
int &&rr=i; //錯誤：不能將一個右值引用綁定到一個左值上
int &r2=i*42;//錯誤：i*42是一個右值
const int &r3=i*42;//正確：我們可以將一個const的引用綁定到一個右值上
int &&rr2=i*42; //正確：將rr2綁定到乘法結果上

返回左值引用的函數，連同賦值、下標/解引用和前置遞增/遞減運算符，都是返回左值的表達式。我們可以將一個左值引用綁定到這類表達式的結果上。

返回非引用類型的函數，連同算術、關系、位以及后置遞增/遞減運算符，都生成右值。我們不能將一個左值引用綁定到這類表達式上，但我們可以將一個const的左值引用或者一個右值引用綁定到這類表達式上。

左值持久，右值短暫

左值有持久的狀態，而右值要么是字面常量，要么是在表達式求值過程中創建的臨時對象

右值引用只能綁定到臨時對象：

• 所引用的對象將要被銷毀
• 該對象沒有其他用戶

這兩個特性意味著：使用右值引用的代碼可以自由地接管所引用的對象的資源。

變量是左值

變量表達式都是左值，變量是持久的，直至離開作用域時才被銷毀。
因此我們不能將一個右值引用綁定到一個右值引用類型的變量上：

int &&rr1 = 42;//正確：字面常量是右值
int &&rr2 = rr1;//錯誤：表達式rr1是左值

標準庫move函數

雖然我們不能將一個右值引用直接綁定到一個左值上，但是我們可以顯式地將一個左值轉換為對應的右值引用類型。我們還可以通過調用一個名為move的新標準庫函數來獲得綁定到左值上的右值引用，move函數定義在頭文件utility中。

int &&rr3 = std::move(rr1);//正確

使用move的代碼應該使用std::move而不是move。這樣做可以避免潛在的名字沖突。

移動構造函數和移動賦值運算符

類似string類（及其他標準庫類），如果我們自己的類也同時支持移動和拷貝，那么也能從中受益。為了讓我們自己的類型支持移動操作，需要為其定義移動構造函數和移動賦值運算符。這兩個成員類似對應的拷貝操作，但它們從給定對象“竊取”資源而不是拷貝資源。

移動構造函數

類似拷貝構造函數，移動構造函數的第一個參數是該類類型的一個引用，不同于拷貝構造函數的是，這個引用參數在移動構造函數中是一個右值引用。與拷貝構造函數一樣，任何額外的參數都必須有默認實參。

除了完成資源移動，移動構造函數還必須確保移后源對象處于這樣一個狀態——銷毀它是無害的。特別是，一旦資源完成移動，源對象必須不再指向被移動的資源——這些資源的所有權已經歸屬新創建的對象。

StrVec的移動構造函數示例：

StrVec::StrVec(StrVec&&s)noexcept:elements(s.elements),first_free(s.first_free),cap(s.cap) 
{s.elements = s.first_free = s.cap=nullptr;
}

與構造函數不同，移動構造函數不分配任何新內存；它接管給定的StrVec中的內存。在接管內存之后，它將給定對象中的指針都置為nullptr。這樣就完成了從給定對象的移動操作，此對象將繼續存在。最終，移后源對象會被銷毀，意味著將在其上運行析構函數。StrVec的析構函數在first_free上調用deallocate。如果我們忘記了改變s.elements ，s.first_free，s.cap，則銷毀移后源對象就會釋放掉我們剛剛移動的內存。

移動操作、標準庫容器和異常

由于移動操作“竊取”資源，它通常不分配任何資源。因此，移動操作通常不會拋出任何異常。當編寫一個不拋出異常的移動操作時，我們應該將此事通知標準庫。我們將看到，除非標準庫知道我們的移動構造函數不會拋出異常，否則它會認為移動我們的類對象時，可能會拋出異常，并且為了處理這種可能性而做一些額外的工作。

我們在一個函數的參數列表后指定noexcept，即為通知標準庫函數不拋出異常。

移動賦值運算符

移動賦值運算符執行與析構函數和移動構造函數相同的工作。與移動構造函數一樣，如果我們的移動賦值運算符不拋出任何異常，我們就應該將它標記為noexcept。類似拷貝賦值運算符，移動賦值運算符必須正確處理自賦值：

StrVec的移動賦值運算符示例：

StrVec & StrVec::operator=(StrVec&&rhs)noexcept {//直接自檢測if (this!=&rhs) {free();//釋放已有元素elements = rhs.elements;//從rhs接管資源first_free = rhs.first_free;cap = rhs.cap;//將rhs置于可析構狀態rhs.elements = rhs.first_free = rhs.cap = nullptr;}return *this;
}

在此例中，我們直接檢查this指針與rhs的地址是否相同。如果相同，右側和左側運算對象指向相同的對象，我們不需要做任何事情。否則，我們釋放左側運算對象所使用的內存，并接管給定對象的內存。與移動構造函數一樣，我們將rhs中的指針置為nullptr。

移后源對象必須可析構

從一個對象移動數據并不會銷毀此對象，但有時在移動操作完成后，源對象會被銷毀。因此，當我們編寫一個移動操作時，必須確保移后源對象進入一個可析構的狀態。我們的StrVec的移動操作滿足這一要求，這是通過將移后源對象的指針成員置為nullptr來實現的。

在移動操作之后，移后源對象必須保持有效的、可析構的狀態，但是用戶不能對其值進行任何假設。

合成的移動操作

與處理拷貝構造函數和拷貝賦值運算符一樣，編譯器也會合成移動構造函數和移動賦值運算符。 但是合成移動操作的條件與合成拷貝操作的條件大不相同。

與拷貝操作不同，編譯器根本不會為某些類合成移動操作。特別是，如果一個類定義了自己的拷貝構造函數、拷貝賦值運算符或者析構函數，編譯器就不會為它合成移動構造函數和移動賦值運算符了。如果一個類沒有移動操作，通過正常的函數匹配，類會使用對應的拷貝操作來代替移動操作。

只有當一個類沒有定義任何自己版本的拷貝控制成員，且類的每個非static數據成員都可以移動時，編譯器才會為它合成移動構造函數或移動賦值運算符。編譯器可以移動內置類型的成員。如果一個成員是類類型，且該類有對應的移動操作，編譯器也能移動這個成員：

編譯器會為X和hasX合成移動操作：

class X{
private:int i; 	//內置類型可以移動string s;  //string定義了自己的移動操作
}
class hasX{X mem; //X有合成的移動操作
}X x, x2 = std::move(x);  //使用合成的移動構造函數
hasX hx, hx2=std::move(hx);  //使用合成的移動構造函數

移動操作永遠不會隱式定義為刪除的函數

如果一個類定義了一個移動構造函數和/或一個移動賦值運算符，則該類的合成拷貝構造函數和拷貝賦值運算符會被定義為刪除的。【即，定義了一個移動構造函數或移動賦值運算符的類必須也定義自己的拷貝操作。否則這些成員默認地被定義為刪除的】

移動右值，拷貝左值

如果一個類既有移動構造函數，也有拷貝構造函數，編譯器使用普通的函數匹配規則來確定使用哪個構造函數。賦值操作的情況類似。

StrVec v1,v2;
v1=v2;  //v2是左值，使用拷貝賦值
StrVec getVec(istream &);//getVec返回一個右值
v2=getVec(cin);//getVec(cin)是一個右值，使用移動賦值

如果沒有移動構造函數，右值也被拷貝

如果一個類有一個拷貝構造函數但未定義移動構造函數，在此情況下，編譯器不會合成移動構造函數，這意味著此類將有拷貝構造函數但不會有移動構造函數。

class Foo{
public:Foo() = default;Foo(const Foo&);//拷貝構造函數...
}Foo x; 
Foo y(x);//拷貝構造函數，x是一個左值
Foo z(std::move(x));//拷貝構造函數，因為未定義移動構造函數
//std::move(x)返回一個綁定到x的Foo&&，因為沒有移動構造函數， 因此我們可以將一個Foo&&轉換為一個const Foo&，因此使用拷貝構造函數

建議：更新三 / 五法則

所有五個拷貝控制成員應該看作一個整體：一般來說，如果一個類定義了任何一個拷貝操作，它就應該定義所有五個操作。如前所述，某些類必須定義拷貝構造函數、拷貝賦值運算符和析構函數才能正確工作。這些類通常擁有一個資源，而拷貝成員必須拷貝此資源。一般來說，拷貝一個資源會導致一些額外開銷。在這種拷貝并非必要的情況下，定義了移動構造函數和移動賦值運算符的類就可以避免此問題。

移動迭代器

新標準庫中定義了一種移動迭代器適配器。一個移動迭代器通過改變給定迭代器的解引用運算符的行為來適配此迭代器。一般來說，一個迭代器的解引用運算符返回一個指向元素的左值。與其他迭代器不同，移動迭代器的解引用運算符生成一個右值引用。

我們通過調用標準庫的make_move_iterator函數將一個普通迭代器轉換為一個移動迭代器。此函數接受一個迭代器參數，返回一個移動迭代器。

原迭代器的所有其他操作在移動迭代器中都照常工作。由于移動迭代器支持正常的迭代器操作，我們可以將一對移動迭代器傳遞給算法：

auto first = alloc.allocate(newcapacity);
auto last = uninitialized_copy(make_move_iterator(begin()),make_move_iterator(end()),first)

uninitialized_copy對輸入序列中的每個元素調用construct將元素“拷貝”到目的位置。此算法使用迭代器的解引用運算符從輸入序列中提取元素。由于我們傳遞給它的是移動迭代器，因此解引用運算符生成的是一個右值引用，這意味著construct將使用移動構造函數來構造元素。

標準庫不保證哪些算法適用移動迭代器，哪些不適用。由于移動一個對象可能銷毀原對象，因此只有在確信算法在為一個元素賦值或將其傳遞給一個用戶定義的函數后不再訪問它時，才能將移動迭代器傳遞給算法。

右值引用和成員函數

拷貝 / 移動構造函數和賦值運算符有相同的參數模式——一個版本接受一個指向const的左值引用，一個版本接受一個指向非const的右值引用。

例如，定義了push_back的標準庫容器提供兩個版本：

void push_back(const X&) //拷貝：綁定到任意類型的X
void push_back(X&&) //移動：只能綁定到類型X的可修改的右值

我們可以將能轉換為類型X的任何對象傳遞給第一個版本的push_back，此版本從其參數拷貝數據。對于第二個版本，我們只可以傳遞給它非const的右值，因此當我們傳遞一個可修改的右值時，編譯器會選擇運行這個版本，此版本會從其參數移動數據。

string s = "hello";
vec.push_back(s);  //調用push_back(const string&)
vec.push_back("done");  //調用push_back(string&&)

這些調用的差別在于實參是一個左值還是一個右值（從“done”創建的臨時string），具體調用哪個版本據此來決定。

右值和左值引用成員函數

通常，我們在一個對象上調用成員函數，而不管該對象是一個左值還是一個右值。

我們指出this的左值 / 右值屬性的方式與定義const成員函數相同，即，在參數列表后放置一個引用限定符。引用限定符可以是&或&&，分別指出this可以指向一個左值或右值。類似const限定符，引用限定符只能用于（非static）成員函數，且必須同時出現在函數的聲明和定義中。

一個函數可以同時用const和引用限定，在此情況下，引用限定符必須跟隨在const限定符之后。

如果一個成員函數有引用限定符，則具有相同參數列表的所有版本都必須有引用限定符。