精品熟女碰碰人人a久久,多姿,欧美欧美a v日韩中文字幕,日本福利片秋霞国产午夜,欧美成人禁片在线观看

一文詳解C++智能指針的原理、分類及使用


1. 智能指針介紹

為解決裸指針可能導致的內存泄漏問題。如：

a）忘記釋放內存；

b）程序提前退出導致資源釋放代碼未執行到。

就出現了智能指針，能夠做到資源的自動釋放。

 

2. 智能指針的原理和簡單實現

2.1 智能指針的原理

將裸指針封裝為一個智能指針類，需要使用該裸指針時，就創建該類的對象；利用棧區對象出作用域會自動析構的特性，保證資源的自動釋放。

2.2 智能指針的簡單實現

代碼示例：

template class mysmartptr {
public:
  mysmartptr(t* ptr = nullptr):mptr(ptr) { // 創建該對象時，裸指針會傳給對象
  }

  ~mysmartptr() {  // 對象出作用域會自動析構，因此會釋放裸指針指向的資源
      delete mptr;
  }
  
  // *運算符重載
  t& operator*() {  // 提供智能指針的解引用操作，即返回它包裝的裸指針的解引用
      return *mptr; 
  }

  // ->運算符重載
  t* operator->() { // 即返回裸指針
      return mptr;
  }
private:
  t* mptr;
};

class obj {
public:
  void func() {
      cout << "obj::func" << endl;
  }
};

void test01() {

  /*創建一個int型的裸指針，
  使用mysmartptr將其封裝為智能指針對象ptr，ptr對象除了作用域就會自動調用析構函數。
  智能指針就是利用棧上對象出作用域自動析構這一特性。*/
  mysmartptr ptr0(new int);
  *ptr0 = 10;

  mysmartptr ptr1(new obj);
  ptr1->func();
  (ptr1.operator->())->func(); // 等價于上面

  /*  中間異常退出，智能指針也會自動釋放資源。
  if (xxx) {
      throw "....";
  }
  
  if (yyy) {
      return -1;
  }
  */
}

 

3. 智能指針分類

3.1 問題引入

接著使用上述自己實現的智能指針進行拷貝構造：

void test02() {
  mysmartptr p1(new int); // p1指向一塊int型內存空間
  mysmartptr p2(p1);      // p2指向p1指向的內存空間
  
  *p1 = 10;   // 內存空間的值為10
  *p2 = 20;   // 內存空間的值被改為20
}

但運行時出錯：

原因在于p1和p2指向同一塊int型堆區內存空間，p2析構將該int型空間釋放，p1再析構時釋放同一塊內存，則出錯。

那可否使用如下深拷貝解決該問題？

mysmartptr(cosnt mysmartptr& src) {
  mptr = new t(*src.mptr);
}

不可以。因為按照裸指針的使用方式，用戶本意是想將p1和p2都指向該int型堆區內存，使用指針p1、p2都可改變該內存空間的值，顯然深拷貝不符合此場景。

3.2 兩類智能指針

不帶引用計數的智能指針：只能有一個指針管理資源。

auto_ptr；

scoped_ptr；

unique_ptr；.

帶引用計數的智能指針：可以有多個指針同時管理資源。

shared_ptr；強智能指針。

weak_ptr: 弱智能指針。這是特例，不能控制資源的生命周期，不能控制資源的自動釋放！

3.3 不帶引用計數的智能指針

只能有一個指針管理資源。

3.3.1 auto_ptr （不推薦使用）

void test03() {
	auto_ptr ptr1(new int);
	auto_ptr ptr2(ptr1);
	*ptr2 = 20;
	// cout << *ptr2 << endl; // 可訪問*ptr2
	cout << *ptr1 << endl; //訪問*ptr1卻報錯
}

如上代碼，訪問*ptr1為何報錯？

因為調用auto_ptr的拷貝構造將ptr1的值賦值給ptr2后，底層會將ptr1指向nullptr；即將同一個指針拷貝構造多次時，只讓最后一次拷貝的指針管理資源，前面的指針全指向nullptr。

不推薦將auto_ptr存入容器。

3.3.2 scoped_ptr （使用較少）

scoped_ptr已將拷貝構造函數和賦值運算符重載delete了。

scoped_ptr(const scoped_ptr&) = delete; // 刪除拷貝構造
scoped_ptr& operator=(const scoped_ptr&) = delete;  // 刪除賦值重載

3.3.3 unique_ptr （推薦使用）

unique_ptr也已將拷貝構造函數和賦值運算符重載delete。

unique_ptr(const unique_ptr&) = delete; // 刪除拷貝構造
unique_ptr& operator=(const unique_ptr&) = delete;  // 刪除賦值重載

但unique_ptr提供了帶右值引用參數的拷貝構造函數和賦值運算符重載，如下：

void test04() {
	unique_ptr ptr1(new int);
	// unique_ptr ptr2(ptr1);  和scoped_ptr一樣無法通過編譯
	unique_ptr ptr2(std::move(ptr1)); // 但可使用move得到ptr1的右值類型
  // *ptr1  也無法訪問
}

3.4 帶引用計數的智能指針

可以有多個指針同時管理資源。

原理：給智能指針添加其指向資源的引用計數屬性，若引用計數 > 0，則不會釋放資源，若引用計數 = 0就釋放資源。

具體來說：額外創建資源引用計數類，在智能指針類中加入該資源引用計數類的指針作為其中的一個屬性；當使用裸指針創建智能指針對象時，創建智能指針中的資源引用計數對象，并將其中的引用計數屬性初始化為1，當后面對該智能指針對象進行拷貝（使用其他智能指針指向該資源時）或時，需要在其他智能指針對象類中將被拷貝的智能指針對象中的資源引用計數類的指針獲取過來，然后將引用計數+1；當用該智能指針給其他智能指針進行賦值時，因為其他智能指針被賦值后，它們就不指向原先的資源了，原先資源的引用計數就-1，直至引用計數為0時delete掉資源；當智能指針對象析構時，會使用其中的資源引用計數指針將共享的引用計數-1，直至引用計數為0時delete掉資源。

shared_ptr：強智能指針；可改變資源的引用計數。

weak_ptr：弱智能指針；不可改變資源的引用計數。

帶引用計數的智能指針的簡單實現：

/*資源的引用計數類*/
template class refcnt {
public:
  refcnt(t* ptr=nullptr):mptr(ptr) {
      if (mptr != nullptr) {
          mcount = 1; // 剛創建指針指針時，引用計數初始化為1
      }
  }

  void addref() {  // 增加引用計數
      mcount++;
  }

  int delref() {   // 減少引用計數
      mcount--;
      return mcount;
  }
private:
  t* mptr;  // 資源地址
  int mcount; // 資源的引用計數
};

/*智能指針類*/
template class mysmartptr {
public:
  mysmartptr(t* ptr = nullptr) :mptr(ptr) { // 創建該對象時，裸指針會傳給對象
      mprefcnt = new refcnt(mptr);
  }

  ~mysmartptr() {  // 對象出作用域會自動析構，因此會釋放裸指針指向的資源
      if (0 == mprefcnt->delref()) {
          delete mptr;
          mptr = nullptr;
      }
  }

  // *運算符重載
  t& operator*() {  // 提供智能指針的解引用操作，即返回它包裝的裸指針的解引用
      return *mptr;
  }

  // ->運算符重載
  t* operator->() { // 即返回裸指針
      return mptr;
  }

  // 拷貝構造
  mysmartptr(const mysmartptr& src):mptr(src.mptr),mprefcnt(src.mprefcnt) {
      if (mptr != nullptr) {
          mprefcnt->addref();
      }
  }

  // 賦值重載
  mysmartptr& operator=(const mysmartptr& src) {
      if (this == &src) // 防止自賦值
          return *this;

      /*若本指針改為指向src管理的資源，則本指針原先指向的資源的引用計數-1，
      若原資源的引用計數為0，就釋放資源*/
      if (0 == mprefcnt->delref()) {  
          delete mptr;
      }

      mptr = src.mptr;
      mprefcnt = src.mprefcnt;
      mprefcnt->addref();
      return *this;
  }
private:
  t* mptr;  // 指向資源的指針
  refcnt* mprefcnt; // 資源的引用計數
};

強智能指針原理圖：

比如有如下創建強智能指針的語句：

shared_ptr sp1(new int(10));

則如下所示：

（a）智能指針對象sp1中主要包括ptr指針指向其管理的資源，ref指針指向該資源的引用計數，則顯然會開辟兩次內存。

（b）uses為該資源的強智能指針的引用計數，weaks為該資源的弱智能指針的引用計數。

3.4.1 shared_ptr

強智能指針?？筛淖冑Y源的引用計數。

（1）強智能指針的交叉引用問題

class b;

class a {
public:
  a() {
      cout << "a()" << endl;
  }
  ~a() {
      cout << "~a()" << endl;
  }
  shared_ptr _ptrb;
};

class b {
public:
  b() {
      cout << "b()" << endl;
  }
  ~b() {
      cout << "~b()" << endl;
  }
  shared_ptr _ptra;
};

void test06() {
  shared_ptr pa(new a());
  shared_ptr pb(new b());

  pa->_ptrb = pb;
  pb->_ptra = pa;

  /*打印pa、pb指向資源的引用計數*/
  cout << pa.use_count() << endl;
  cout << pb.use_count() << endl;
}

輸出結果：

可見pa、pb指向的資源的引用計數都為2，因此出了作用域導致pa、pb指向的資源都無法釋放，如下圖所示：

解決：

建議定義對象時使用強智能指針，引用對象時使用弱智能指針，防止出現交叉引用的問題。

什么是定義對象？什么是引用對象？

定義對象：

使用new創建對象，并創建一個新的智能指針管理它。

引用對象：

使用一個已存在的智能指針來創建一個新的智能指針。

定義對象和引用對象的示例如下：

shared_ptr p1(new int());              // 定義智能指針對象p1
shared_ptr p2 = make_shared(10);  // 定義智能指針對象p2

shared_ptr p3 = p1;  // 引用智能指針p1，并使用p3來共享它
weak_ptr p4 = p2;    // 引用智能指針p2，并使用p4來觀察它

如上述代碼，因為在test06函數中使用pa對象的_ptrb引用pb對象，使用pb對象的_ptra引用pa對象，因此需要將a類、b類中的_ptrb和_ptra的類型改為弱智能指針weak_ptr即可，這樣就不會改變資源的引用計數，能夠正確釋放資源。

3.4.2 weak_ptr

弱智能指針。不能改變資源的引用計數、不能管理對象生命周期、不能做到資源自動釋放、不能創建對象，也不能訪問資源（因為weak_ptr未提供operator->和operator*運算符重載），即不能通過弱智能指針調用函數、不能將其解引用。只能從一個已有的shared_ptr或weak_ptr獲得資源的弱引用。

弱智能指針weak_ptr若想用訪問資源，則需要使用lock方法將其提升為一個強智能指針，提升失敗則返回nullptr。（提升的情形常使用于多線程環境，避免無效的訪問，提升程序安全性）

注意：弱智能指針weak_ptr只能觀察資源的狀態，但不能管理資源的生命周期，不會改變資源的引用計數，不能控制資源的釋放。

weak_ptr示例：

void test07() {
  shared_ptr boy_sptr(new boy());
  weak_ptr boy_wptr(boy_sptr);
  // boy_wptr->study(); 錯誤！無法使用弱智能指針訪問資源
  cout << boy_sptr.use_count() << endl; // 引用計數為1，因為弱智能指針不改變引用計數

  shared_ptr i_sptr(new int(99));
  weak_ptr i_wptr(i_sptr);
  // cout << *i_wptr << endl; 錯誤！無法使用弱智能指針訪問資源
  cout << i_sptr.use_count() << endl; // 引用計數為1，因為弱智能指針不改變引用計數

  /*弱智能指針提升為強智能指針*/
  shared_ptr boy_sptr1 = boy_wptr.lock();
  if (boy_sptr1 != nullptr) {
      cout << boy_sptr1.use_count() << endl; // 提升成功，引用計數為2
      boy_sptr1->study(); // 可以調用
  }

  shared_ptr i_sptr1 = i_wptr.lock();
  if (i_sptr1 != nullptr) {
      cout << i_sptr1.use_count() << endl; // 提升成功，引用計數為2
      cout << *i_sptr1 << endl; // 可以輸出
  }  
}

 

4. 智能指針與多線程訪問共享資源的安全問題

現要實現主線程創建子線程，讓子線程執行打印hello的函數，有如下兩種方式：

方式1：主線程調用test08函數，在test08函數中啟動子線程執行線程函數，如下：

void handler() {
	cout << "hello" << endl;
}

void func() {
	thread t1(handler);
}

int main(int argc, char** argv) {
	func();
	this_thread::sleep_for(chrono::seconds(1));
	system("pause");
	return 0;
}

運行報錯：

方式2：主線程中直接創建子線程來執行線程函數，如下：

void handler() {
	cout << "hello" << endl;
}

int main(int argc, char** argv) {
  thread t1(handler);
	this_thread::sleep_for(chrono::seconds(1));
	system("pause");
	return 0;
}

運行結果：無報錯

上面兩種方式都旨在通過子線程調用函數輸出hello，但為什么方式1報錯？很簡單，不再贅述。

回歸本節標題的正題，有如下程序：

class c {
public:
  c() {
      cout << "c()" << endl;
  }

  ~c() {
      cout << "~c()" << endl;
  }

  void funcc() {
      cout << "c::funcc()" << endl;
  }
private:

};

/*子線程執行函數*/
void threadhandler(c* c) {
  this_thread::sleep_for(chrono::seconds(1));
  c->funcc();
}

/* 主線程 */
int main(int argc, char** argv) {
  c* c = new c();
  thread t1(threadhandler, c);
  delete c;
	t1.join();
	return 0;
}

運行結果：

結果顯示c指向的對象被析構了，但是仍然使用該被析構的對象調用了其中的funcc函數，顯然不合理。

因此在線程函數中，使用c指針訪問a對象時，需要觀察a對象是否存活。

使用弱智能指針weak_ptr接收對象，訪問對象之前嘗試提升為強智能指針shared_ptr，提升成功則訪問，否則對象被析構。

情形1：對象被訪問之前就被析構了：

class c {
public:
  c() {
      cout << "c()" << endl;
  }

  ~c() {
      cout << "~c()" << endl;
  }

  void funcc() {
      cout << "c::funcc()" << endl;
  }
private:

};

/*子線程執行函數*/
void threadhandler(weak_ptr pw) {  // 引用時使用弱智能指針
  this_thread::sleep_for(chrono::seconds(1));
  shared_ptr ps = pw.lock();  // 嘗試提升
  if (ps != nullptr) {
      ps->funcc();
  } else {
      cout << "對象已經析構！" << endl;
  }
}

/* 主線程 */
int main(int argc, char** argv) {
  {
      shared_ptr p(new c());
      thread t1(threadhandler, weak_ptr(p));
      t1.detach();
  }
  this_thread::sleep_for(chrono::seconds(5));
	return 0;
}

運行結果：

情形2： 對象訪問完才被析構：

class c {
public:
  c() {
      cout << "c()" << endl;
  }

  ~c() {
      cout << "~c()" << endl;
  }

  void funcc() {
      cout << "c::funcc()" << endl;
  }
private:

};

/*子線程執行函數*/
void threadhandler(weak_ptr pw) {  // 引用時使用弱智能指針
  this_thread::sleep_for(chrono::seconds(1));
  shared_ptr ps = pw.lock();  // 嘗試提升
  if (ps != nullptr) {
      ps->funcc();
  } else {
      cout << "對象已經析構！" << endl;
  }
}

/* 主線程 */
int main(int argc, char** argv) {
  {
      shared_ptr p(new c());
      thread t1(threadhandler, weak_ptr(p));
      t1.detach();
      this_thread::sleep_for(chrono::seconds(5));
  }  
	return 0;
}

運行結果：

可見shared_ptr與weak_ptr結合使用，能夠較好地保證多線程訪問共享資源的安全。

 

5.智能指針的刪除器deleter

刪除器是智能指針釋放資源的方式，默認使用操作符delete來釋放資源。

但并非所有智能指針管理的資源都可通過delete釋放，如數組、文件資源、數據庫連接資源等。

有如下智能指針對象管理一個數組資源：

unique_ptr ptr1(new int[100]);

此時再用默認的刪除器則會造成資源泄露，因此需要自定義刪除器。

一些為部分自定義刪除器的示例：

/* 方式1：類模板 */
template class mydeleter {
public:
  void operator()(t* ptr) const {
      cout << "數組自定義刪除器1." << endl;
      delete[] ptr;
  }
};

/* 方式2：函數 */
void mydeleter(int* p) {
  cout << "數組自定義刪除器2." << endl;
  delete[] p;
}

void test09() {
  unique_ptr
相關文章