C++智能指針與類模板

時間  2019-11-09
標籤 c++ 智能 指針 模板 欄目 C&C++ 简体版
原文   原文鏈接

智能指針是行爲相似於指針的類對象，全部的智能指針都會重載 -> 和 * 操做符。智能指針還有許多其餘功能，比較有用的是自動銷燬。這主要是利用棧對象的有限做用域以及臨時對象（有限做用域實現）析構函數釋放內存。固然，智能指針還不止這些，還包括複製時能夠修改源對象等。智能指針根據需求不一樣，設計也不一樣（寫時複製，賦值即釋放對象擁有權限、引用計數等，控制權轉移等）。智能指針是存儲指向動態分配（堆）對象指針的類，用於生存期控制，可以確保自動正確的銷燬動態分配的對象，防止內存泄露。 智能指針類將一個計數器與類指向的對象相關聯，引用計數跟蹤該類有多少個對象共享同一指針。每次建立類的新對象時，初始化指針並將引用計數置爲1；當對象做爲另外一對象的副本而建立時，拷貝構造函數拷貝指針並增長與之相應的引用計數；對一個對象進行賦值時，賦值操做符減小左操做數所指對象的引用計數（若是引用計數爲減至0，則刪除對象），並增長右操做數所指對象的引用計數；調用析構函數時，構造函數減小引用計數（若是引用計數減至0，則刪除基礎對象）。 本文主要介紹3個可幫助管理動態內存分配的智能指針模板（auto_ptr、unique_ptr和shared_ptr）。html

目錄ios

一、智能指針設計思想算法

二、智能指針簡單介紹數組

三、爲什麼摒棄auto_ptr安全

四、unique_ptr爲什麼優於auto_ptr函數

五、如何選擇智能指針ui

正文spa

一、智能指針設計思想.net

先來看一下須要哪些功能以及這些功能是如何實現的。請看下面的函數：設計

?

1

2

3

4

5

6

7

void remodel(std::string & str)

{

    std::string * ps = new std::string(str);

    ...

    str = ps;

    return;

}

 每當調用時，該函數都分配堆中的內存，但從不收回，從而致使內存泄漏。此時只要不忘記在return前添加下面語句釋放內存便可：

?

1

delete ps ;

 然而，請你們再看一個例子：

?

1

2

3

4

5

6

7

8

9

10

void remodel(std::string & str)

{

    std::string * ps = new std::string(str);

    ...

    if (weird_thing())

        throw exception();

    str = *ps;

    delete ps;

    return;

}

當拋出異常時，delete將不被執行，所以也將致使內存泄漏。問題顯現出來了吧，有沒有一種靈巧的解決辦法呢？這就是本文要說的智能指針！

如今來看一下，若是設計一個智能指針須要什麼。

當remodel()這樣的函數終止（不論是正常終止，仍是異常終止），本地變量都將從棧內存中刪除——指針ps佔據的內存將被釋放。若是ps指向的內存也被釋放，那該有多好啊。若是ps有一個析構函數，該析構函數將在ps過時時釋放它指向的內存。所以，ps的問題在於，它只是一個常規指針，不是有析構函數的類對象。若是它是對象，則在對象過時時，讓它的析構函數刪除指向的內存。這個正就是智能指針模板（auto_ptr、unique_ptr和shared_ptr）背後的思想。

按如下3個步驟用智能指針模板auto_ptr進行轉換remodel()函數：

  • 包含頭義件memory（智能指針所在的頭文件）；
  • 將指向string的指針替換爲指向string的智能指針對象；
  • 刪除delete語句。

?

1

2

3

4

5

6

7

8

9

10

11

12

#include <memory>

using namespace std;

void remodel(std::string & str)

{

    std::auto_ptr<std::string> ps(new std::string(str))；

        ...

    if (weird_thing())

        throw exception()；

        str = *ps；

        // delete ps； NO LONGER NEEDED

        return;

}

 二、智能指針簡單介紹

在介紹以前先看一個簡單程序，再對智能指針做一個簡單的介紹。該程序演示瞭如何使用3種智能指針。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

//smrtptrs.cpp --using three kinds of smart pointers

//requires support of C++11 shared_ptr and unique_ptr

#include <iostream>

#include <string>

#include <memory>

using namespace std;

 

class Report{

private:

    string str;

public:

    Report(const string s):str(s){

        cout << "Object created !" << endl;

    }

    ~Report(){

        cout << "Object deleted !" << endl;

    }

    void comment() const{

        cout << str << endl;

    }

};

 

int main(){

    {

        auto_ptr<Report> ps(new Report("using auto_ptr"));

        ps->comment();

    }

    {

        unique_ptr<Report> ps(new Report("using unique_ptr"));

        ps->comment();

    }

    {

        shared_ptr<Report> ps(new Report("using shared_ptr"));

        ps->comment();

    }

    return 0;

}

執行結果：

?

1

2

3

4

5

6

7

8

9

Object created !

using auto_ptr

Object deleted !

Object created !

using unique_ptr

Object deleted !

Object created !

using shared_ptr

Object deleted !

如今來分析一下這三個智能指針模板（auto_ptr、unique_ptr和shared_ptr）。

咱們能夠將new得到（直接或者間接）的地址賦給這種對象，當智能指針過時時，其析構函數將使用delete來釋放內存。

要建立智能指針對象，必須包含文件memory，該文件含有智能指針模板的定義，而後使用一般的模板語法來實例化所需類型的指針。全部的智能指針類都有一個explicit構造函數，例如，其中智能指針auto_ptr包含以下構造函數：

?

1

2

3

4

5

templet<class T>class auto_ptr {

public:

    explicit auto_ptr(X* p = 0) throw{};

        ...

};

所以，請求X類型的auto_ptr將得到一個指向X類型的auto_ptr：

?

1

2

3

4

auto_ptr<double> pd(new double);// pd  an auto_ptr to double

// use in place of double *pd

auto_ptr<string> pd(new string);// pd  an auto_ptr to string

// use in place of double *string

new double 是new 返回的指針，指向新分配的內存塊，它是auto_ptr<double>的參數，即對應於原型中形參p的實參。一樣，new string也是構造函數的實參。另外兩種智能指針使用一樣的語法：

?

1

2

unique_ptr<double> pd(new double);

shared_ptr<double> pd(new double);

可是要注意的是，三種智能指針都應該避免一點：

?

1

2

string vacation("I wandered lonely as a cloud.");

shared_ptr<string> pvac(&vacation);   // No

pvac過時時，程序將把delete運算符用於非堆內存，這是錯誤的。

三、爲什麼摒棄auto_ptr

先來看下面的賦值語句：

?

1

2

3

auto_ptr<string>  ps (new string ("I reigned lonely as a cloud.」）;

auto_ptr<string>  vocation;

vocaticn = ps;

上述賦值語句將完成什麼工做呢？若是ps和vocation是常規指針，則兩個指針將指向同一個string對象。這是不能接受的，由於程序將試圖刪除同一個對象兩次——一次是ps過時時，另外一次是vocation過時時。要避免這種問題，方法有多種：

  • 定義陚值運算符，使之執行深複製。這樣兩個指針將指向不一樣的對象，其中的一個對象是另外一個對象的副本，缺點是浪費空間，因此智能指針都未採用此方案。

  • 創建全部權（ownership）概念。對於特定的對象，只能有一個智能指針可擁有，這樣只有擁有對象的智能指針的構造函數會刪除該對象。而後讓賦值操做轉讓全部權。這就是用於auto_ptr和uniqiie_ptr 的策略，但unique_ptr的策略更嚴格。

  • 建立智能更高的指針，跟蹤引用特定對象的智能指針數。這稱爲引用計數。例如，賦值時，計數將加1，而指針過時時，計數將減1,。當減爲0時才調用delete。這是shared_ptr採用的策略。

固然，一樣的策略也適用於複製構造函數。

每種方法都有其用途，但爲什麼說要摒棄auto_ptr呢？

先看一個例子：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

#include <iostream>

#include <string>

#include <memory>

using namespace std;

 

int main() {

  auto_ptr<string> films[5] =

 {

  auto_ptr<string> (new string("Fowl Balls")),

  auto_ptr<string> (new string("Duck Walks")),

  auto_ptr<string> (new string("Chicken Runs")),

  auto_ptr<string> (new string("Turkey Errors")),

  auto_ptr<string> (new string("Goose Eggs"))

 };

 auto_ptr<string> pwin;

 pwin = films[2]; // films[2] loses ownership. 將全部權從films[2]轉讓給pwin，此時films[2]再也不引用該字符串從而變成空指針

 

 cout << "The nominees for best avian baseballl film are\n";

 for(int i = 0; i < 5; ++i)

  cout << *films[i] << endl;

 cout << "The winner is " << *pwin << endl;

 cin.get();

 

 return 0;

}

該程序運行結果是崩潰了，可是，若是把auto_ptr<string> pwin;改爲shared_ptr<string> pwin;編譯後執行結果卻正常了。若是把auto_ptr<string> pwin;改爲unique_ptr<string> pwin;編譯語句pwin = films[2];時不能經過。

緣由以下：

  • 使用shared_ptr時運行正常，由於shared_ptr採用引用計數，pwin和films[2]都指向同一塊內存，在釋放空間時由於事先要判斷引用計數值的大小所以不會出現屢次刪除一個對象的錯誤。

  • 使用unique_ptr時編譯出錯，與auto_ptr同樣，unique_ptr也採用全部權模型，但在使用unique_ptr時，程序不會等到運行階段崩潰，而在編譯器因下述代碼行出現錯誤。

四、unique_ptr爲什麼優於auto_ptr

可能你們認爲前面的例子已經說明了unique_ptr爲什麼優於auto_ptr，也就是安全問題，下面再敘述的清晰一點。請看下面的語句：

?

1

2

3

auto_ptr<string> p1(new string ("auto") ； //#1

auto_ptr<string> p2;                       //#2

p2 = p1;                                   //#3

在語句#3中，p2接管string對象的全部權後，p1的全部權將被剝奪。前面說過，這是好事，可防止p1和p2的析構函數試圖刪同—個對象；但若是程序隨後試圖使用p1，這將是件壞事，由於p1再也不指向有效的數據。

下面來看使用unique_ptr的狀況：

?

1

2

3

unique_ptr<string> p3 (new string ("auto");   //#4

unique_ptr<string> p4;                       //#5

p4 = p3;                                      //#6

編譯器認爲語句#6非法，避免了p3再也不指向有效數據的問題。所以，unique_ptr比auto_ptr更安全（編譯階段錯誤比潛在的程序崩潰更安全）。

有時候，會將一個智能指針賦給另外一個並不會留下危險的懸掛指針。假設有以下函數定義：

?

1

2

3

4

5

unique_ptr<string> demo(const char * s)

{

    unique_ptr<string> temp (new string (s));

    return temp;

}

並假設編寫了以下代碼：

?

1

unique_ptr<string> ps;<br>ps = demo('Uniquely special");

demo() 返回一個臨時unique_ptr，而後ps接管了本來歸返回的unique_ptr全部的對象，而返回時臨時的 unique_ptr 被銷燬，也就是說沒有機會使用 unique_ptr 來訪問無效的數據，換句話來講，這種賦值是不會出現任何問題的，即沒有理由禁止這種賦值。實際上，編譯器確實容許這種賦值。

總之，當程序試圖將一個 unique_ptr 賦值給另外一個時，若是源 unique_ptr 是個臨時右值，編譯器容許這麼作；若是源 unique_ptr 將存在一段時間，編譯器將禁止這麼作，好比：

?

1

2

3

4

unique_ptr<string> pu1(new string ("hello world"));

unique_ptr<string> pu2;_x000D_pu2 = pu1;          // #1 not allowed

unique_ptr<string> pu3;

pu3 = unique_ptr<string>(new string ("yoyos"));   // #2 allowed

其中#1留下懸掛的unique_ptr(pu1)，這可能致使危害。而#2不會留下懸掛的unique_ptr，由於它調用 unique_ptr 的構造函數，該構造函數建立的臨時對象在其全部權讓給 pu3 後就會被銷燬。這種隨狀況而已的行爲代表，unique_ptr 優於容許兩種賦值的auto_ptr 。

固然，您可能確實想執行相似於#1的操做，僅當以非智能的方式使用摒棄的智能指針時（如解除引用時），這種賦值纔不安全。要安全的重用這種指針，可給它賦新值。C++ 有一個標準庫函數std::move()，讓你可以將一個unique_ptr賦給另外一個。原來的指針仍轉讓全部權變成空指針，能夠對其從新賦值。下面是一個使用前述demo()函數的例子，該函數返回一個 unique_ptr<string> 對象：

?

1

2

3

4

5

unique_ptr<string> ps1, ps2;

ps1 = demo("hello");

ps2 = move(ps1);

ps1 = demo("alexia");

cout << *ps2 << *ps1 << endl;

相比於auto_ptr，unique_ptr還有另外一個優勢，它有一個可用於數組的變體，這裏就不做細節討論了。

五、如何選擇智能指針

在現實中咱們該如何選擇智能指針呢？下面給出幾個選擇方法：

  • 若是程序要使用多個指向同一個對象的指針，應選擇shared_ptr。
  1. 有一個指針數組，並使用一些輔助指針來標示特定的元素，如最大的元素和最小的元素；
  2. 兩個對象包含都指向第三個對象的指針；
  3. STL容器包含指針。不少STL算法都支持複製和賦值操做，這些操做可用於shared_ptr，但不能用於unique_ptr（編譯器發出warning）和auto_ptr（行爲不肯定）。若是你的編譯器沒有提供shared_ptr，可以使用Boost庫提供的shared_ptr。
  • 若是程序不須要多個指向同一個對象的指針，則可以使用unique_ptr。
  • 若是函數使用new分配內存，並返還指向該內存的指針，將其返回類型聲明爲unique_ptr是不錯的選擇。這樣，全部權轉讓給接受返回值的unique_ptr，而該智能指針將負責調用delete。可將unique_ptr存儲到STL容器在那個，只要不調用將一個unique_ptr複製或賦給另外一個算法（如sort()）。例如，可在程序中使用相似於下面的代碼段：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

unique_ptr<int> make_int(int n)

{

    return unique_ptr<int>(new int(n));

}

void show(unique_ptr<int> &p1)

{

    cout << *a << ' ';

}

int main()

{

    ...

    vector<unique_ptr<int> > vp(size);

    for(int i = 0; i < vp.size(); i++)

        vp[i] = make_int(rand() % 1000);              // copy temporary unique_ptr

    vp.push_back(make_int(rand() % 1000));     // ok because arg is temporary

    for_each(vp.begin(), vp.end(), show);           // use for_each()

    ...

}

其中push_back調用沒有問題，由於它返回一個臨時unique_ptr，該unique_ptr被賦給vp中的一個unique_ptr。另外，如 果按值而不是按引用給show()傳遞對象，for_each()將非法，由於這將致使使用一個來自vp的非臨時unique_ptr初始化pi，而這是 不容許的。前面說過，編譯器將發現錯誤使用unique_ptr的企圖。

在unique_ptr爲右值時，可將其賦給shared_ptr，這與將一個unique_ptr賦給一個須要知足的條件相同。與前面同樣，在下面的代碼中，make_int()的返回類型爲unique_ptr<int>：

?

1

2

3

unique_ptr<int> pup(make_int(rand() % 1000));   // ok

shared_ptr<int> spp(pup);                       // not allowed, pup as lvalue

hared_ptr<int> spr(make_int(rand() % 1000));   // ok

模板shared_ptr包含一個顯式構造函數，可用於將右值unique_ptr轉換爲shared_ptr。shared_ptr將接管原來歸unique_ptr全部的對象。

在知足unique_ptr要求的條件時，也可以使用auto_ptr，但unique_ptr是更好的選擇。若是你的編譯器沒有unique_ptr，可考慮使用Boost庫提供的scoped_ptr，它與unique_ptr相似。

 

https://blog.csdn.net/crusierliu/article/details/82432265

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程