文章目錄

• 前言
• 拷貝、賦值與銷毀
• • 拷貝構(gòu)造函數(shù)
  • • 合成拷貝構(gòu)造函數(shù)
    • 拷貝初始化和直接初始化
    • • 拷貝初始化的發(fā)生：
    • 參數(shù)和返回值
    • 拷貝初始化的限制
  • 拷貝賦值運(yùn)算符
  • • 重載賦值運(yùn)算符
    • 合成拷貝賦值運(yùn)算符
  • 析構(gòu)函數(shù)
  • • 析構(gòu)函數(shù)完成的工作
    • 什么時(shí)候會(huì)調(diào)用析構(gòu)函數(shù)
    • 合成析構(gòu)函數(shù)
    • 代碼片段調(diào)用幾次析構(gòu)函數(shù)
  • 根據(jù)代碼理解 拷貝構(gòu)造函數(shù)、拷貝賦值運(yùn)算符以及析構(gòu)函數(shù)何時(shí)執(zhí)行
  • 三 / 五法則
  • • 需要析構(gòu)函數(shù)的類也需要拷貝和賦值操作
    • • 示例代碼
    • 需要拷貝操作的類也需要賦值操作，反之亦然
    • • 示例代碼
      • • 沒有拷貝構(gòu)造的類
        • 有拷貝構(gòu)造的類
  • =default
  • 阻止拷貝
  • • 定義刪除的函數(shù)
    • 析構(gòu)函數(shù)不能是刪除函數(shù)的成員
    • 合成的拷貝控制成員可能是刪除的
• 拷貝控制和資源管理
• • 行為像值的類
  • • 示例代碼
    • 類值拷貝賦值運(yùn)算符
  • 定義行為像指針的類
  • • 示例代碼
• 交換操作
• 拷貝控制示例
• • 示例代碼【兩個(gè)類相互調(diào)用】
• 動(dòng)態(tài)內(nèi)存管理類
• • StrVec類的設(shè)計(jì)
  • • reallocate成員函數(shù)
    • • 移動(dòng)構(gòu)造函數(shù)
      • std::move
    • StrVec代碼
• 對(duì)象移動(dòng)
• • 右值引用
  • • 左值持久，右值短暫
    • 變量是左值
    • 標(biāo)準(zhǔn)庫move函數(shù)
  • 移動(dòng)構(gòu)造函數(shù)和移動(dòng)賦值運(yùn)算符
  • • 移動(dòng)構(gòu)造函數(shù)
    • • 移動(dòng)操作、標(biāo)準(zhǔn)庫容器和異常
    • 移動(dòng)賦值運(yùn)算符
    • 移后源對(duì)象必須可析構(gòu)
    • 合成的移動(dòng)操作
    • • 移動(dòng)操作永遠(yuǎn)不會(huì)隱式定義為刪除的函數(shù)
    • 移動(dòng)右值，拷貝左值
    • 如果沒有移動(dòng)構(gòu)造函數(shù)，右值也被拷貝
    • 建議：更新三 / 五法則
    • 移動(dòng)迭代器
  • 右值引用和成員函數(shù)
  • • 右值和左值引用成員函數(shù)

前言

當(dāng)定義一個(gè)類時(shí)，我們顯式或隱式地指定在此類型的對(duì)象拷貝、移動(dòng)、賦值和銷毀時(shí)做什么。一個(gè)類通過定義五種特殊的成員函數(shù)來控制這些操作，包括：拷貝構(gòu)造函數(shù)、拷貝賦值運(yùn)算符、移動(dòng)構(gòu)造函數(shù)、移動(dòng)賦值運(yùn)算符和析構(gòu)函數(shù)?？截惡鸵苿?dòng)構(gòu)造函數(shù)定義了當(dāng)用同類型的另一個(gè)對(duì)象初始化本對(duì)象時(shí)做什么?？截惡鸵苿?dòng)賦值運(yùn)算符定義了將一個(gè)對(duì)象賦予同類型的另一個(gè)對(duì)象時(shí)做什么。析構(gòu)函數(shù)定義了當(dāng)此類型對(duì)象銷毀時(shí)做什么。我們稱這些操作為拷貝控制操作。

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

拷貝、賦值與銷毀

拷貝構(gòu)造函數(shù)

如果一個(gè)構(gòu)造函數(shù)的第一個(gè)參數(shù)是自身類類型的引用，且任何額外參數(shù)都有默認(rèn)值，則此構(gòu)造函數(shù)是拷貝構(gòu)造函數(shù)：

class Foo{Foo();//默認(rèn)構(gòu)造函數(shù)Foo(const Foo&); //拷貝構(gòu)造函數(shù) }

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

合成拷貝構(gòu)造函數(shù)

如果我們沒有為一個(gè)類定義拷貝構(gòu)造函數(shù)，編譯器會(huì)為我們定義一個(gè)。與合成默認(rèn)構(gòu)造函數(shù)不同，即使我們定義了其他構(gòu)造函數(shù)，編譯器也會(huì)為我們合成一個(gè)拷貝構(gòu)造函數(shù)。

一般情況下，合成的拷貝構(gòu)造函數(shù)會(huì)將其參數(shù)的成員逐個(gè)拷貝到正在創(chuàng)建的對(duì)象中。編譯器從給定對(duì)象中依次將每個(gè)非static成員拷貝到正在創(chuàng)建的對(duì)象中。對(duì)內(nèi)置類型的成員，直接進(jìn)行內(nèi)存拷貝，對(duì)類類型的成員，調(diào)用其拷貝構(gòu)造函數(shù)進(jìn)行拷貝。

拷貝初始化和直接初始化

當(dāng)使用直接初始化時(shí)，我們實(shí)際上是要求編譯器使用普通的函數(shù)匹配來選擇與我們提供的參數(shù)最匹配的構(gòu)造函數(shù)。當(dāng)我們使用拷貝初始化時(shí)，我們要求編譯器將右側(cè)運(yùn)算對(duì)象拷貝到正在創(chuàng)建的對(duì)象中，如果需要的話還要進(jìn)行類型轉(zhuǎn)換。

拷貝初始化的發(fā)生：

• 用 = 定義變量時(shí)
• 將一個(gè)對(duì)象作為實(shí)參傳遞給一個(gè)非引用類型的形參
• 從一個(gè)返回類型為非引用類型的函數(shù)返回一個(gè)對(duì)象
• 用花括號(hào)列表初始化一個(gè)數(shù)組中的元素或一個(gè)聚合類中的成員
• 初始化標(biāo)準(zhǔn)庫容器或調(diào)用其insert/push操作時(shí)，容器會(huì)對(duì)其元素進(jìn)行拷貝初始化

參數(shù)和返回值

在函數(shù)調(diào)用過程中，具有非引用類型的參數(shù)要進(jìn)行拷貝初始化。類似的，當(dāng)一個(gè)函數(shù)具有非引用的返回類型時(shí)，返回值會(huì)被用來初始化調(diào)用方的結(jié)果。

拷貝構(gòu)造函數(shù)的第一個(gè)參數(shù)必須是一個(gè)引用類型的原因：
拷貝構(gòu)造函數(shù)被用來初始化非引用類類型參數(shù)。如果拷貝構(gòu)造函數(shù)自己的參數(shù)不是引用類型，則調(diào)用永遠(yuǎn)也不會(huì)成功——為了調(diào)用拷貝構(gòu)造函數(shù)，我們必須拷貝它的實(shí)參，但為了拷貝實(shí)參，我們又需要調(diào)用拷貝構(gòu)造函數(shù)，如此無限循環(huán)。

拷貝初始化的限制

如前所述，如果我們使用的初始化值要求通過一個(gè)explicit的構(gòu)造函數(shù)來進(jìn)行類型轉(zhuǎn)換，那么使用拷貝初始化還是直接初始化就不是無關(guān)緊要的了：

拷貝賦值運(yùn)算符

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

Sales_data trans,accum; trans = accum; //使用Sales_data的拷貝賦值運(yùn)算符

與拷貝構(gòu)造函數(shù)一樣，如果類未定義自己的拷貝賦值運(yùn)算符，編譯器會(huì)為它合成一個(gè)。

重載賦值運(yùn)算符

重載運(yùn)算符本質(zhì)上是函數(shù)，其名字由operator關(guān)鍵字后接表示要定義的運(yùn)算符的符號(hào)組成。因此賦值運(yùn)算符就是一個(gè)名為 operator= 的函數(shù)，類似于任何其他函數(shù)，運(yùn)算符函數(shù)也有一個(gè)返回類型和一個(gè)參數(shù)列表。

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

為了與內(nèi)置類型的賦值保持一致，賦值運(yùn)算符通常返回一個(gè)指向其左側(cè)運(yùn)算對(duì)象的引用。另外，標(biāo)準(zhǔn)庫通常要求保存在容器中的類型要具有賦值運(yùn)算符，且其返回值是左側(cè)運(yùn)算對(duì)象的引用。

賦值運(yùn)算符通常應(yīng)該返回一個(gè)指向其左側(cè)運(yùn)算對(duì)象的引用。

合成拷貝賦值運(yùn)算符

與處理拷貝構(gòu)造函數(shù)一樣，如果一個(gè)類未定義自己的拷貝賦值運(yùn)算符，編譯器會(huì)為它生成一個(gè)合成拷貝賦值運(yùn)算符。

通常情況下，合成的拷貝賦值運(yùn)算符會(huì)將右側(cè)對(duì)象的非static成員逐個(gè)賦予左側(cè)對(duì)象的對(duì)應(yīng)成員，這些賦值操作是由成員類型的拷貝賦值運(yùn)算符來完成的。

析構(gòu)函數(shù)

析構(gòu)函數(shù)執(zhí)行與構(gòu)造函數(shù)相反的操作：構(gòu)造函數(shù)初始化對(duì)象的非static數(shù)據(jù)成員，還可能做一些其他工作；析構(gòu)函數(shù)釋放對(duì)象使用的資源，并銷毀對(duì)象的非static數(shù)據(jù)成員。

析構(gòu)函數(shù)沒有返回值，也不接受參數(shù)：

class Foo{ public:~Foo();//析構(gòu)函數(shù) }

由于析構(gòu)函數(shù)不接受參數(shù)，因此它不能被重載。對(duì)一個(gè)給定類，只會(huì)有唯一一個(gè)析構(gòu)函數(shù)。

析構(gòu)函數(shù)完成的工作

在一個(gè)構(gòu)造函數(shù)中，成員的初始化是在函數(shù)體執(zhí)行之前完成的，且按照它們?cè)陬愔谐霈F(xiàn)的順序進(jìn)行初始化。在一個(gè)析構(gòu)函數(shù)中，首先執(zhí)行函數(shù)體，然后銷毀成員。成員按初始化順序的逆序銷毀。

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

隱式銷毀一個(gè)內(nèi)置指針類型的成員不會(huì)delete它所指向的對(duì)象。

與普通指針不同，智能指針是類類型，所以具有析構(gòu)函數(shù)。因此與普通指針不同，智能指針成員在析構(gòu)階段會(huì)被自動(dòng)銷毀。

什么時(shí)候會(huì)調(diào)用析構(gòu)函數(shù)

無論何時(shí)一個(gè)對(duì)象被銷毀，就會(huì)自動(dòng)調(diào)用其析構(gòu)函數(shù)

• 變量在離開其作用域時(shí)被銷毀
• 當(dāng)一個(gè)對(duì)象被銷毀時(shí)，其成員被銷毀
• 容器（無論是標(biāo)準(zhǔn)庫容器還是數(shù)組）被銷毀時(shí)，其元素被銷毀
• 對(duì)于動(dòng)態(tài)分配的對(duì)象，當(dāng)對(duì)指向它的指針應(yīng)用delete運(yùn)算符時(shí)被銷毀
• 對(duì)于臨時(shí)對(duì)象，當(dāng)創(chuàng)建它的完整表達(dá)式結(jié)束時(shí)被銷毀

由于析構(gòu)函數(shù)自動(dòng)運(yùn)行，我們的程序可以按需分配資源，無需擔(dān)心何時(shí)釋放這些資源。

當(dāng)指向一個(gè)對(duì)象的引用或指針離開作用域時(shí)，析構(gòu)函數(shù)不會(huì)執(zhí)行。

合成析構(gòu)函數(shù)

當(dāng)一個(gè)類未定義自己的析構(gòu)函數(shù)時(shí)，編譯器會(huì)為它定義一個(gè)合成析構(gòu)函數(shù)。

析構(gòu)函數(shù)體自身并不直接銷毀成員。成員是在析構(gòu)函數(shù)體之后隱含的析構(gòu)階段中被銷毀的。在整個(gè)對(duì)象銷毀過程中，析構(gòu)函數(shù)體是作為成員銷毀步驟之外的另一部分而進(jìn)行的。

代碼片段調(diào)用幾次析構(gòu)函數(shù)

代碼一：指針 調(diào)用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);

其中析構(gòu)函數(shù)為：

~Sales_data() { cout << "這是在執(zhí)行Sales_data的析構(gòu)函數(shù)..." << endl; }

輸出結(jié)果：

這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)...

調(diào)用三次析構(gòu)函數(shù)：

• 函數(shù)結(jié)束時(shí)，局部變量item1和item2的生命期結(jié)束，被銷毀，Sales_data的析構(gòu)函數(shù)被調(diào)用
• 函數(shù)結(jié)束時(shí)，參數(shù)accum的生命期結(jié)束，被銷毀，Sales_data的析構(gòu)函數(shù)被調(diào)用
• 在函數(shù)結(jié)束時(shí)，trans的生命期也結(jié)束了，但它是Sales_data的指針，并不是它指向的Sales_data對(duì)象的生命期結(jié)束（只有delete指針時(shí)，指向的動(dòng)態(tài)對(duì)象的生命期才結(jié)束）

代碼二：引用 調(diào)用3次

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

輸出結(jié)果：

這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)...

代碼三：調(diào)用4次

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

輸出結(jié)果：

這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)... 這是在執(zhí)行Sales_data的析構(gòu)函數(shù)...

根據(jù)代碼理解 拷貝構(gòu)造函數(shù)、拷貝賦值運(yùn)算符以及析構(gòu)函數(shù)何時(shí)執(zhí)行

Y類

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

測試代碼：

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

輸出結(jié)果：

局部變量： 構(gòu)造函數(shù)Y()非引用參數(shù)傳遞： 拷貝構(gòu)造函數(shù)Y(const Y&) 析構(gòu)函數(shù)~Y()引用參數(shù)傳遞：動(dòng)態(tài)分配： 構(gòu)造函數(shù)Y()添加到容器中： 拷貝構(gòu)造函數(shù)Y(const Y&)釋放動(dòng)態(tài)分配對(duì)象： 析構(gòu)函數(shù)~Y()間接初始化和賦值： 拷貝構(gòu)造函數(shù)Y(const Y&) 拷貝賦值運(yùn)算符=(const Y&)程序結(jié)束； 析構(gòu)函數(shù)~Y() 析構(gòu)函數(shù)~Y() 析構(gòu)函數(shù)~Y()

程序結(jié)束后的三次Y的析構(gòu)函數(shù)分別是tmp，vector中的元素和y
編譯器可以略過對(duì)拷貝構(gòu)造函數(shù)的調(diào)用。

三 / 五法則

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

需要析構(gòu)函數(shù)的類也需要拷貝和賦值操作

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

示例代碼

如果我們?yōu)镠asPtr定義一個(gè)析構(gòu)函數(shù)，但使用合成版本的拷貝構(gòu)造函數(shù)和拷貝賦值運(yùn)算符：

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; }

在該示例中，當(dāng)foo運(yùn)行完畢后，hp和ret都會(huì)被銷毀，在兩個(gè)對(duì)象上都會(huì)調(diào)用HasPtr的析構(gòu)函數(shù)，此析構(gòu)函數(shù)會(huì)delete ret和hp中的指針成員，但這兩個(gè)對(duì)象包含相同的指針值（因?yàn)楹铣傻目截悩?gòu)造函數(shù)和拷貝賦值運(yùn)算符，只是簡單的拷貝指針成員，因此ret和hp中的指針成員指向相同的內(nèi)存），此代碼會(huì)導(dǎo)致此指針值被delete兩次，這顯然是一個(gè)錯(cuò)誤。

因此，如果一個(gè)類需要自定義析構(gòu)函數(shù)，幾乎可以肯定它也需要自定義拷貝賦值運(yùn)算符和拷貝構(gòu)造函數(shù)。

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

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

示例代碼

沒有拷貝構(gòu)造的類

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

無論 f 函數(shù)是值傳遞還是引用傳遞結(jié)果均為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); }

輸出結(jié)果：

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

有拷貝構(gòu)造的類

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

參數(shù)是值傳遞，在傳參的過程中，又進(jìn)行了拷貝構(gòu)造，故輸出結(jié)果為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); }

輸出結(jié)果：

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

參數(shù)是引用傳遞：

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); }

輸出結(jié)果：

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

=default

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

我們只能對(duì)具有合成版本的成員函數(shù)使用 =default （即，默認(rèn)構(gòu)造函數(shù)或拷貝控制成員）

阻止拷貝

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

定義刪除的函數(shù)

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

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

與 =default 不同，=delete 必須出現(xiàn)在函數(shù)第一次聲明的時(shí)候。此外，我們可以對(duì)任何函數(shù)指定 =delete（我們只能對(duì)編譯器可以合成的默認(rèn)構(gòu)造函數(shù)或拷貝控制成員使用 =default）。雖然刪除函數(shù)的主要用途是禁止拷貝控制成員，但當(dāng)我們希望引導(dǎo)函數(shù)匹配過程時(shí)，刪除函數(shù)有時(shí)也是有用的。

析構(gòu)函數(shù)不能是刪除函數(shù)的成員

值得注意的是，我們不能刪除析構(gòu)函數(shù)。因?yàn)槿绻鰳?gòu)函數(shù)被刪除，就無法銷毀此類型的對(duì)象了。對(duì)于一個(gè)刪除了析構(gòu)函數(shù)的類型，編譯器將不允許定義該類型的變量或創(chuàng)建該類的臨時(shí)變量。

對(duì)于刪除了析構(gòu)函數(shù)的類型，雖然我們不能定義這種類型的變量或成員，但可以動(dòng)態(tài)分配這種類型的對(duì)象，但是不能釋放指向該類型動(dòng)態(tài)分配對(duì)象的指針。

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

如果一個(gè)類未定義拷貝控制成員或構(gòu)造函數(shù)，編譯器會(huì)定義默認(rèn)的合成版本。對(duì)某些類來說，編譯器將這些合成的成員定義為刪除的函數(shù)：

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

本質(zhì)上，這些規(guī)則的含義是：如果一個(gè)類有數(shù)據(jù)成員不能默認(rèn)構(gòu)造、拷貝、復(fù)制或銷毀，則對(duì)應(yīng)的成員函數(shù)將被定義為刪除的。

拷貝控制和資源管理

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

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

類的行為像一個(gè)值，意味著它應(yīng)該也有自己的狀態(tài)。當(dāng)我們拷貝一個(gè)像值的對(duì)象時(shí)，副本和原對(duì)象是完全獨(dú)立的。改變副本不會(huì)對(duì)原對(duì)象有任何影響，反之亦然。

行為像指針的類則共享狀態(tài)。當(dāng)我們拷貝一個(gè)這種類的對(duì)象時(shí)，副本和原對(duì)象使用相同的底層數(shù)據(jù)。改變副本也會(huì)改變?cè)瓕?duì)象，反之亦然。

標(biāo)準(zhǔn)庫容器和string類的行為像一個(gè)值。shared_ptr類提供類似指針的行為。IO類型和unique_ptr不允許拷貝或賦值，因此它們的行為既不像值也不像指針。

行為像值的類

為了提供類值的行為，對(duì)于類管理的資源，每個(gè)對(duì)象都應(yīng)該擁有一份自己的拷貝。這意味著對(duì)于ps指向的string，每個(gè)HasPtr對(duì)象都必須有自己的拷貝。為了實(shí)現(xiàn)類值行為，HasPtr需要：

• 定義一個(gè)拷貝構(gòu)造函數(shù)，完成string的拷貝，而不是拷貝指針
• 定義一個(gè)析構(gòu)函數(shù)來釋放string
• 定義一個(gè)拷貝賦值運(yùn)算符來釋放對(duì)象當(dāng)前的string，并從右側(cè)運(yùn)算對(duì)象拷貝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){}為什么拷貝構(gòu)造函數(shù)的參數(shù)可以直接去訪問它自己的私有成員?
對(duì)象能否訪問到私有成員與其定義的位置有關(guān)：在類內(nèi)定義，可以訪問，在類外定義，不能訪問。在類的成員函數(shù)中可以訪問同類型實(shí)例對(duì)象的私有成員變量。

類值拷貝賦值運(yùn)算符

賦值運(yùn)算符通常組合了析構(gòu)函數(shù)和構(gòu)造函數(shù)的操作。類似析構(gòu)函數(shù)， 賦值操作會(huì)銷毀左側(cè)運(yùn)算對(duì)象的資源。類似拷貝構(gòu)造函數(shù)，賦值操作會(huì)從右側(cè)運(yùn)算對(duì)象拷貝數(shù)據(jù)。這些操作是以正確的順序執(zhí)行的，即使將一個(gè)對(duì)象賦予它自身，也保證正確。而且，如果可能，我們編寫的賦值運(yùn)算符還應(yīng)該是異常安全的——當(dāng)異常發(fā)生時(shí)能將左側(cè)運(yùn)算對(duì)象置于一個(gè)有意義的狀態(tài)。

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

當(dāng)編寫賦值運(yùn)算符時(shí)，有兩點(diǎn)需要記住：

• 如果將一個(gè)對(duì)象賦予它自身，賦值運(yùn)算符必須能正確工作。
• 大多數(shù)賦值運(yùn)算符組合了析構(gòu)函數(shù)和拷貝構(gòu)造函數(shù)的工作。

當(dāng)編寫一個(gè)賦值運(yùn)算符時(shí)，一個(gè)好的模式是先將右側(cè)運(yùn)算對(duì)象拷貝到一個(gè)局部臨時(shí)對(duì)象中。當(dāng)拷貝完成后，銷毀左側(cè)運(yùn)算對(duì)象的現(xiàn)有成員就是安全的了。一旦左側(cè)運(yùn)算對(duì)象的資源被銷毀，就只剩下將數(shù)據(jù)從臨時(shí)對(duì)象拷貝到左側(cè)運(yùn)算對(duì)象的成員中了。

定義行為像指針的類

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

令一個(gè)類展現(xiàn)類似指針的行為的最好方法是使用shared_ptr來管理類中的資源。

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

• 除了初始化對(duì)象外，每個(gè)構(gòu)造函數(shù)（拷貝構(gòu)造函數(shù)除外）還要?jiǎng)?chuàng)建一個(gè)引用計(jì)數(shù)，用來記錄有多少對(duì)象與正在創(chuàng)建的對(duì)象共享狀態(tài)。當(dāng)我們創(chuàng)建一個(gè)對(duì)象時(shí)，只有一個(gè)對(duì)象共享狀態(tài)，因此將計(jì)數(shù)器初始化為1。
• 拷貝構(gòu)造函數(shù)不分配新的計(jì)數(shù)器，而是拷貝給定對(duì)象的數(shù)據(jù)成員，包括計(jì)數(shù)器?？截悩?gòu)造函數(shù)遞增共享的計(jì)數(shù)器，指出給定對(duì)象的狀態(tài)又被一個(gè)新用戶所共享。
• 析構(gòu)函數(shù)遞減計(jì)數(shù)器，指出共享狀態(tài)的用戶少了一個(gè)。如果計(jì)數(shù)器變?yōu)?，則析構(gòu)函數(shù)釋放狀態(tài)。
• 拷貝賦值運(yùn)算符遞增右側(cè)運(yùn)算對(duì)象的計(jì)數(shù)器，遞減左側(cè)運(yùn)算對(duì)象的計(jì)數(shù)器。如果左側(cè)運(yùn)算對(duì)象的計(jì)數(shù)器變?yōu)?，意味著它的共享狀態(tài)沒有用戶了，拷貝賦值運(yùn)算符就必須銷毀狀態(tài)。

我們將計(jì)數(shù)器保存在動(dòng)態(tài)內(nèi)存中，當(dāng)創(chuàng)建一個(gè)對(duì)象時(shí)，我們也分配一個(gè)新的計(jì)數(shù)器。當(dāng)拷貝或賦值對(duì)象時(shí)，我們拷貝指向計(jì)數(shù)器的指針。使用這種方法，副本和原對(duì)象都會(huì)指向相同的計(jì)數(shù)器。

示例代碼

class HasPtr { public://構(gòu)造函數(shù)分配新的string和新的計(jì)數(shù)器，將計(jì)數(shù)器置為1HasPtr(const string &s = string()) :ps(new string(s)), i(0),use(new size_t(1)) {}//拷貝構(gòu)造函數(shù)拷貝所有三個(gè)數(shù)據(jù)成員，并遞增計(jì)數(shù)器HasPtr(const HasPtr &p) :ps(p.ps), i(p.i), use(p.use) { ++*use; }//賦值運(yùn)算符HasPtr& operator=(const HasPtr &rhs) {++*rhs.use;//遞增右側(cè)運(yùn)算對(duì)象的引用計(jì)數(shù)if (--*use == 0) { //遞減本對(duì)象的引用計(jì)數(shù)，delete ps; //如果計(jì)數(shù)為0，則釋放本對(duì)象分配的成員delete use;}ps = rhs.ps; //將數(shù)據(jù)從rhs拷貝到本對(duì)象i = rhs.i;use = rhs.use;return *this; //返回本對(duì)象}//析構(gòu)函數(shù)~HasPtr() {//如果引用計(jì)數(shù)變?yōu)?，則釋放string內(nèi)存，釋放計(jì)數(shù)器內(nèi)存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 的計(jì)數(shù)，減少hp4原計(jì)數(shù)器的計(jì)數(shù)，賦值操作后，hp4和hp1指向相同的內(nèi)存，故hp3計(jì)數(shù)為1，其余計(jì)數(shù)為3hp1.printUse(); //3hp2.printUse(); //3hp3.printUse(); //1hp4.printUse(); //3

交換操作

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

如果一個(gè)類定義了自己的swap，那么算法將使用類自定義版本。否則，算法將使用標(biāo)準(zhǔn)庫定義的swap。雖然與往常一樣我們不知道swap是如何實(shí)現(xiàn)的，但理論上很容易理解，為了交換兩個(gè)對(duì)象我們需要進(jìn)行一次拷貝和兩次賦值。

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

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

拷貝控制示例

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

示例代碼【兩個(gè)類相互調(diào)用】

我們定義Message和Folder類，為了記錄Message位于哪些Folder中，每個(gè)Message都會(huì)保存一個(gè)它所在Folder的指針的set集合，同樣的，每個(gè)Folder都保存一個(gè)它包含的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&);//拷貝構(gòu)造函數(shù)Message& operator=(const Message&);//拷貝賦值運(yùn)算符~Message();//析構(gòu)函數(shù)//從給定Folder集合中添加/刪除本Messagevoid save(Folder&);void remove(Folder&);void addFldr(Folder *f) {folders.insert(f);}private:string contents; //實(shí)際消息文本set<Folder*>folders; //包含本Message的Folder//工具函數(shù)//將本Message添加到指向參數(shù)的Folder中void add_to_Folders(const Message&);//從folders中的每個(gè)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集合中移除 }//工具函數(shù) //將本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); } //從對(duì)應(yīng)的Folder中刪除本Message void Message::remove_from_Folders() {for (auto f : folders)f->remMsg(this); } Message::~Message() {remove_from_Folders(); } //我們先從左側(cè)運(yùn)算對(duì)象的folders中刪除此Message的指針， //然后再將指針添加到右側(cè)運(yùn)算對(duì)象的folders中， //從而實(shí)現(xiàn)了自賦值的正確處理 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;} }

測試函數(shù)：

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();

輸出結(jié)果：

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

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

動(dòng)態(tài)內(nèi)存管理類

某些類需要在運(yùn)行時(shí)分配可變大小的內(nèi)存空間。這種類通?？梢允褂脴?biāo)準(zhǔn)庫容器來存放它們的數(shù)據(jù)。這種類通?？梢?#xff08;并且如果它們確實(shí)可以的話，一般應(yīng)該）使用標(biāo)準(zhǔn)庫容器來保存它們的數(shù)據(jù)。

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

StrVec類的設(shè)計(jì)

我們實(shí)現(xiàn)標(biāo)準(zhǔn)庫vector類的一個(gè)簡化版本，即不使用模板，只用于string。

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

reallocate成員函數(shù)

移動(dòng)構(gòu)造函數(shù)

通過使用標(biāo)準(zhǔn)庫引入的兩種機(jī)制，我們就可以避免string的拷貝。有一些標(biāo)準(zhǔn)庫類，包括string，都定義了所謂的“移動(dòng)構(gòu)造函數(shù)”，移動(dòng)構(gòu)造函數(shù)通常是將資源從給定對(duì)象“移動(dòng)”而不是拷貝到正在創(chuàng)建的對(duì)象。

std::move

標(biāo)準(zhǔn)庫函數(shù)move，定義在utility頭文件中。關(guān)于move，我們需要了解兩個(gè)關(guān)鍵點(diǎn)，首先，當(dāng)reallocate在新內(nèi)存中構(gòu)造string時(shí)，它必須調(diào)用move來表示希望使用string的移動(dòng)構(gòu)造函數(shù)。如果它漏掉了move調(diào)用，將會(huì)使用string的拷貝構(gòu)造函數(shù)。其次，我們通常不為move提供一個(gè)using聲明，當(dāng)我們使用move時(shí)，直接調(diào)用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&);//拷貝構(gòu)造函數(shù)StrVec &operator=(const StrVec&);//拷貝賦值運(yùn)算符~StrVec();//析構(gòu)函數(shù)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;//被添加元素的函數(shù)使用void chk_n_alloc() {if (size() == capacity())reallocate();}//工具函數(shù)，被拷貝構(gòu)造函數(shù)、賦值運(yùn)算符和析構(gòu)函數(shù)所使用pair<string*, string*> alloc_n_copy(const string*,const string*);void free();//銷毀元素并釋放內(nèi)存void reallocate();//獲得更多內(nèi)存并拷貝已有元素string * elements;//指向數(shù)組首元素的指針string * first_free;//指向數(shù)組第一個(gè)空閑元素的指針string * cap;//指向數(shù)組尾后位置的指針 };void StrVec::push_back(const string&s) {chk_n_alloc();alloc.construct(first_free++,s); }//此函數(shù)返回一個(gè)指針的pair，兩個(gè)指針分別指向新空間的開始位置和拷貝的尾后的位置pair<string*, string*> StrVec::alloc_n_copy(const string*b, const string*e) {//分配空間保存給定范圍中的元素auto data = alloc.allocate(e-b);//初始化并返回一個(gè)pair，該pair由data和uninitialized_copy的返回值構(gòu)成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函數(shù) //為一個(gè)新的更大的string數(shù)組分配內(nèi)存 //在內(nèi)存空間的前一部分構(gòu)造對(duì)象，保存現(xiàn)有元素 //銷毀原內(nèi)存空間中的元素，并釋放這塊內(nèi)存 void StrVec::reallocate() {//我們將分配當(dāng)前大小兩倍的內(nèi)存空間auto newcapacity = size() ? 2 * size() : 1;//分配新內(nèi)存auto newdata = alloc.allocate(newcapacity);//將數(shù)據(jù)從舊內(nèi)存移動(dòng)到新內(nèi)存auto dest = newdata;//指向新數(shù)組中下一個(gè)空閑位置auto elem = elements;//指向舊數(shù)組中下一個(gè)元素for (size_t i = 0;i != size();++i) {alloc.construct(dest++,std::move(*elem++));}free();//一旦我們移動(dòng)完元素就釋放舊內(nèi)存空間//更新我們的數(shù)據(jù)結(jié)構(gòu)，執(zhí)行新元素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; }

輸出結(jié)果：從輸出結(jié)果可以看出，當(dāng)進(jìn)行push_back操作時(shí)，若沒有空間添加新元素，則將分配當(dāng)前大小兩倍的內(nèi)存空間

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

對(duì)象移動(dòng)

新標(biāo)準(zhǔn)的一個(gè)最主要的特性是可以移動(dòng)而非拷貝對(duì)象的能力。在某些情況下，對(duì)象拷貝后就立即被銷毀了，此時(shí)移動(dòng)而非拷貝對(duì)象會(huì)大幅度提升性能。

標(biāo)準(zhǔn)庫容器、string和shared_ptr類既支持移動(dòng)也支持拷貝。IO類和unique_ptr類可以移動(dòng)但不能拷貝。

右值引用

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

一般而言，一個(gè)左值表達(dá)式表示的是一個(gè)對(duì)象的身份，而一個(gè)右值表達(dá)式表示的是對(duì)象的值。

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

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

返回左值引用的函數(shù)，連同賦值、下標(biāo)/解引用和前置遞增/遞減運(yùn)算符，都是返回左值的表達(dá)式。我們可以將一個(gè)左值引用綁定到這類表達(dá)式的結(jié)果上。

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

左值持久，右值短暫

左值有持久的狀態(tài)，而右值要么是字面常量，要么是在表達(dá)式求值過程中創(chuàng)建的臨時(shí)對(duì)象

右值引用只能綁定到臨時(shí)對(duì)象：

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

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

變量是左值

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

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

標(biāo)準(zhǔn)庫move函數(shù)

雖然我們不能將一個(gè)右值引用直接綁定到一個(gè)左值上，但是我們可以顯式地將一個(gè)左值轉(zhuǎn)換為對(duì)應(yīng)的右值引用類型。我們還可以通過調(diào)用一個(gè)名為move的新標(biāo)準(zhǔn)庫函數(shù)來獲得綁定到左值上的右值引用，move函數(shù)定義在頭文件utility中。

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

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

移動(dòng)構(gòu)造函數(shù)和移動(dòng)賦值運(yùn)算符

類似string類（及其他標(biāo)準(zhǔn)庫類），如果我們自己的類也同時(shí)支持移動(dòng)和拷貝，那么也能從中受益。為了讓我們自己的類型支持移動(dòng)操作，需要為其定義移動(dòng)構(gòu)造函數(shù)和移動(dòng)賦值運(yùn)算符。這兩個(gè)成員類似對(duì)應(yīng)的拷貝操作，但它們從給定對(duì)象“竊取”資源而不是拷貝資源。

移動(dòng)構(gòu)造函數(shù)

類似拷貝構(gòu)造函數(shù)，移動(dòng)構(gòu)造函數(shù)的第一個(gè)參數(shù)是該類類型的一個(gè)引用，不同于拷貝構(gòu)造函數(shù)的是，這個(gè)引用參數(shù)在移動(dòng)構(gòu)造函數(shù)中是一個(gè)右值引用。與拷貝構(gòu)造函數(shù)一樣，任何額外的參數(shù)都必須有默認(rèn)實(shí)參。

除了完成資源移動(dòng)，移動(dòng)構(gòu)造函數(shù)還必須確保移后源對(duì)象處于這樣一個(gè)狀態(tài)——銷毀它是無害的。特別是，一旦資源完成移動(dòng)，源對(duì)象必須不再指向被移動(dòng)的資源——這些資源的所有權(quán)已經(jīng)歸屬新創(chuàng)建的對(duì)象。

StrVec的移動(dòng)構(gòu)造函數(shù)示例：

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

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

移動(dòng)操作、標(biāo)準(zhǔn)庫容器和異常

由于移動(dòng)操作“竊取”資源，它通常不分配任何資源。因此，移動(dòng)操作通常不會(huì)拋出任何異常。當(dāng)編寫一個(gè)不拋出異常的移動(dòng)操作時(shí)，我們應(yīng)該將此事通知標(biāo)準(zhǔn)庫。我們將看到，除非標(biāo)準(zhǔn)庫知道我們的移動(dòng)構(gòu)造函數(shù)不會(huì)拋出異常，否則它會(huì)認(rèn)為移動(dòng)我們的類對(duì)象時(shí)，可能會(huì)拋出異常，并且為了處理這種可能性而做一些額外的工作。

我們?cè)谝粋€(gè)函數(shù)的參數(shù)列表后指定noexcept，即為通知標(biāo)準(zhǔn)庫函數(shù)不拋出異常。

移動(dòng)賦值運(yùn)算符

移動(dòng)賦值運(yùn)算符執(zhí)行與析構(gòu)函數(shù)和移動(dòng)構(gòu)造函數(shù)相同的工作。與移動(dòng)構(gòu)造函數(shù)一樣，如果我們的移動(dòng)賦值運(yùn)算符不拋出任何異常，我們就應(yīng)該將它標(biāo)記為noexcept。類似拷貝賦值運(yùn)算符，移動(dòng)賦值運(yùn)算符必須正確處理自賦值：

StrVec的移動(dòng)賦值運(yùn)算符示例：

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

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

移后源對(duì)象必須可析構(gòu)

從一個(gè)對(duì)象移動(dòng)數(shù)據(jù)并不會(huì)銷毀此對(duì)象，但有時(shí)在移動(dòng)操作完成后，源對(duì)象會(huì)被銷毀。因此，當(dāng)我們編寫一個(gè)移動(dòng)操作時(shí)，必須確保移后源對(duì)象進(jìn)入一個(gè)可析構(gòu)的狀態(tài)。我們的StrVec的移動(dòng)操作滿足這一要求，這是通過將移后源對(duì)象的指針成員置為nullptr來實(shí)現(xiàn)的。

在移動(dòng)操作之后，移后源對(duì)象必須保持有效的、可析構(gòu)的狀態(tài)，但是用戶不能對(duì)其值進(jìn)行任何假設(shè)。

合成的移動(dòng)操作

與處理拷貝構(gòu)造函數(shù)和拷貝賦值運(yùn)算符一樣，編譯器也會(huì)合成移動(dòng)構(gòu)造函數(shù)和移動(dòng)賦值運(yùn)算符。 但是合成移動(dòng)操作的條件與合成拷貝操作的條件大不相同。

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

只有當(dāng)一個(gè)類沒有定義任何自己版本的拷貝控制成員，且類的每個(gè)非static數(shù)據(jù)成員都可以移動(dòng)時(shí)，編譯器才會(huì)為它合成移動(dòng)構(gòu)造函數(shù)或移動(dòng)賦值運(yùn)算符。編譯器可以移動(dòng)內(nèi)置類型的成員。如果一個(gè)成員是類類型，且該類有對(duì)應(yīng)的移動(dòng)操作，編譯器也能移動(dòng)這個(gè)成員：

編譯器會(huì)為X和hasX合成移動(dòng)操作：

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

移動(dòng)操作永遠(yuǎn)不會(huì)隱式定義為刪除的函數(shù)

如果一個(gè)類定義了一個(gè)移動(dòng)構(gòu)造函數(shù)和/或一個(gè)移動(dòng)賦值運(yùn)算符，則該類的合成拷貝構(gòu)造函數(shù)和拷貝賦值運(yùn)算符會(huì)被定義為刪除的?！?strong>即，定義了一個(gè)移動(dòng)構(gòu)造函數(shù)或移動(dòng)賦值運(yùn)算符的類必須也定義自己的拷貝操作。否則這些成員默認(rèn)地被定義為刪除的】

移動(dòng)右值，拷貝左值

如果一個(gè)類既有移動(dòng)構(gòu)造函數(shù)，也有拷貝構(gòu)造函數(shù)，編譯器使用普通的函數(shù)匹配規(guī)則來確定使用哪個(gè)構(gòu)造函數(shù)。賦值操作的情況類似。

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

如果沒有移動(dòng)構(gòu)造函數(shù)，右值也被拷貝

如果一個(gè)類有一個(gè)拷貝構(gòu)造函數(shù)但未定義移動(dòng)構(gòu)造函數(shù)，在此情況下，編譯器不會(huì)合成移動(dòng)構(gòu)造函數(shù)，這意味著此類將有拷貝構(gòu)造函數(shù)但不會(huì)有移動(dòng)構(gòu)造函數(shù)。

class Foo{ public:Foo() = default;Foo(const Foo&);//拷貝構(gòu)造函數(shù)... }Foo x; Foo y(x);//拷貝構(gòu)造函數(shù)，x是一個(gè)左值 Foo z(std::move(x));//拷貝構(gòu)造函數(shù)，因?yàn)槲炊x移動(dòng)構(gòu)造函數(shù) //std::move(x)返回一個(gè)綁定到x的Foo&&，因?yàn)闆]有移動(dòng)構(gòu)造函數(shù)， 因此我們可以將一個(gè)Foo&&轉(zhuǎn)換為一個(gè)const Foo&，因此使用拷貝構(gòu)造函數(shù)

建議：更新三 / 五法則

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

移動(dòng)迭代器

新標(biāo)準(zhǔn)庫中定義了一種移動(dòng)迭代器適配器。一個(gè)移動(dòng)迭代器通過改變給定迭代器的解引用運(yùn)算符的行為來適配此迭代器。一般來說，一個(gè)迭代器的解引用運(yùn)算符返回一個(gè)指向元素的左值。與其他迭代器不同，移動(dòng)迭代器的解引用運(yùn)算符生成一個(gè)右值引用。

我們通過調(diào)用標(biāo)準(zhǔn)庫的make_move_iterator函數(shù)將一個(gè)普通迭代器轉(zhuǎn)換為一個(gè)移動(dòng)迭代器。此函數(shù)接受一個(gè)迭代器參數(shù)，返回一個(gè)移動(dòng)迭代器。

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

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

uninitialized_copy對(duì)輸入序列中的每個(gè)元素調(diào)用construct將元素“拷貝”到目的位置。此算法使用迭代器的解引用運(yùn)算符從輸入序列中提取元素。由于我們傳遞給它的是移動(dòng)迭代器，因此解引用運(yùn)算符生成的是一個(gè)右值引用，這意味著construct將使用移動(dòng)構(gòu)造函數(shù)來構(gòu)造元素。

標(biāo)準(zhǔn)庫不保證哪些算法適用移動(dòng)迭代器，哪些不適用。由于移動(dòng)一個(gè)對(duì)象可能銷毀原對(duì)象，因此只有在確信算法在為一個(gè)元素賦值或?qū)⑵鋫鬟f給一個(gè)用戶定義的函數(shù)后不再訪問它時(shí)，才能將移動(dòng)迭代器傳遞給算法。

右值引用和成員函數(shù)

拷貝 / 移動(dòng)構(gòu)造函數(shù)和賦值運(yùn)算符有相同的參數(shù)模式——一個(gè)版本接受一個(gè)指向const的左值引用，一個(gè)版本接受一個(gè)指向非const的右值引用。

例如，定義了push_back的標(biāo)準(zhǔn)庫容器提供兩個(gè)版本：

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

我們可以將能轉(zhuǎn)換為類型X的任何對(duì)象傳遞給第一個(gè)版本的push_back，此版本從其參數(shù)拷貝數(shù)據(jù)。對(duì)于第二個(gè)版本，我們只可以傳遞給它非const的右值，因此當(dāng)我們傳遞一個(gè)可修改的右值時(shí)，編譯器會(huì)選擇運(yùn)行這個(gè)版本，此版本會(huì)從其參數(shù)移動(dòng)數(shù)據(jù)。

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

這些調(diào)用的差別在于實(shí)參是一個(gè)左值還是一個(gè)右值（從“done”創(chuàng)建的臨時(shí)string），具體調(diào)用哪個(gè)版本據(jù)此來決定。

右值和左值引用成員函數(shù)

通常，我們?cè)谝粋€(gè)對(duì)象上調(diào)用成員函數(shù)，而不管該對(duì)象是一個(gè)左值還是一個(gè)右值。

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

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

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

總結(jié)

以上是生活随笔為你收集整理的C++ primer 第13章 拷贝控制的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。