1. 智能指針介紹

為解決裸指針可能導(dǎo)致的內(nèi)存泄漏問題。如：

a）忘記釋放內(nèi)存；

b）程序提前退出導(dǎo)致資源釋放代碼未執(zhí)行到。

就出現(xiàn)了智能指針，能夠做到資源的自動(dòng)釋放。

2. 智能指針的原理和簡單實(shí)現(xiàn)

2.1 智能指針的原理

將裸指針封裝為一個(gè)智能指針類，需要使用該裸指針時(shí)，就創(chuàng)建該類的對(duì)象；利用棧區(qū)對(duì)象出作用域會(huì)自動(dòng)析構(gòu)的特性，保證資源的自動(dòng)釋放。

2.2 智能指針的簡單實(shí)現(xiàn)

代碼示例：

template class mysmartptr {
public:
  mysmartptr(t* ptr = nullptr):mptr(ptr) { // 創(chuàng)建該對(duì)象時(shí)，裸指針會(huì)傳給對(duì)象
  }

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

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

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

void test01() {

  /*創(chuàng)建一個(gè)int型的裸指針，
  使用mysmartptr將其封裝為智能指針對(duì)象ptr，ptr對(duì)象除了作用域就會(huì)自動(dòng)調(diào)用析構(gòu)函數(shù)。
  智能指針就是利用棧上對(duì)象出作用域自動(dòng)析構(gòu)這一特性。*/
  mysmartptr ptr0(new int);
  *ptr0 = 10;

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

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

3. 智能指針分類

3.1 問題引入

接著使用上述自己實(shí)現(xiàn)的智能指針進(jìn)行拷貝構(gòu)造：

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

但運(yùn)行時(shí)出錯(cuò)：

原因在于p1和p2指向同一塊int型堆區(qū)內(nèi)存空間，p2析構(gòu)將該int型空間釋放，p1再析構(gòu)時(shí)釋放同一塊內(nèi)存，則出錯(cuò)。

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

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

不可以。因?yàn)榘凑章阒羔樀氖褂梅绞?，用戶本意是想將p1和p2都指向該int型堆區(qū)內(nèi)存，使用指針p1、p2都可改變?cè)搩?nèi)存空間的值，顯然深拷貝不符合此場景。

3.2 兩類智能指針

不帶引用計(jì)數(shù)的智能指針：只能有一個(gè)指針管理資源。

auto_ptr；

scoped_ptr；

unique_ptr；.

帶引用計(jì)數(shù)的智能指針：可以有多個(gè)指針同時(shí)管理資源。

shared_ptr；強(qiáng)智能指針。

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

3.3 不帶引用計(jì)數(shù)的智能指針

只能有一個(gè)指針管理資源。

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卻報(bào)錯(cuò)
}

如上代碼，訪問*ptr1為何報(bào)錯(cuò)？

因?yàn)檎{(diào)用auto_ptr的拷貝構(gòu)造將ptr1的值賦值給ptr2后，底層會(huì)將ptr1指向nullptr；即將同一個(gè)指針拷貝構(gòu)造多次時(shí)，只讓最后一次拷貝的指針管理資源，前面的指針全指向nullptr。

不推薦將auto_ptr存入容器。

3.3.2 scoped_ptr （使用較少）

scoped_ptr已將拷貝構(gòu)造函數(shù)和賦值運(yùn)算符重載delete了。

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

3.3.3 unique_ptr （推薦使用）

unique_ptr也已將拷貝構(gòu)造函數(shù)和賦值運(yùn)算符重載delete。

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

但unique_ptr提供了帶右值引用參數(shù)的拷貝構(gòu)造函數(shù)和賦值運(yùn)算符重載，如下：

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

3.4 帶引用計(jì)數(shù)的智能指針

可以有多個(gè)指針同時(shí)管理資源。

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

具體來說：額外創(chuàng)建資源引用計(jì)數(shù)類，在智能指針類中加入該資源引用計(jì)數(shù)類的指針作為其中的一個(gè)屬性；當(dāng)使用裸指針創(chuàng)建智能指針對(duì)象時(shí)，創(chuàng)建智能指針中的資源引用計(jì)數(shù)對(duì)象，并將其中的引用計(jì)數(shù)屬性初始化為1，當(dāng)后面對(duì)該智能指針對(duì)象進(jìn)行拷貝（使用其他智能指針指向該資源時(shí)）或時(shí)，需要在其他智能指針對(duì)象類中將被拷貝的智能指針對(duì)象中的資源引用計(jì)數(shù)類的指針獲取過來，然后將引用計(jì)數(shù)+1；當(dāng)用該智能指針給其他智能指針進(jìn)行賦值時(shí)，因?yàn)槠渌悄苤羔槺毁x值后，它們就不指向原先的資源了，原先資源的引用計(jì)數(shù)就-1，直至引用計(jì)數(shù)為0時(shí)delete掉資源；當(dāng)智能指針對(duì)象析構(gòu)時(shí)，會(huì)使用其中的資源引用計(jì)數(shù)指針將共享的引用計(jì)數(shù)-1，直至引用計(jì)數(shù)為0時(shí)delete掉資源。

shared_ptr：強(qiáng)智能指針；可改變資源的引用計(jì)數(shù)。

weak_ptr：弱智能指針；不可改變資源的引用計(jì)數(shù)。

帶引用計(jì)數(shù)的智能指針的簡單實(shí)現(xiàn)：

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

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

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

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

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

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

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

  // 拷貝構(gòu)造
  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管理的資源，則本指針原先指向的資源的引用計(jì)數(shù)-1，
      若原資源的引用計(jì)數(shù)為0，就釋放資源*/
      if (0 == mprefcnt->delref()) {  
          delete mptr;
      }

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

強(qiáng)智能指針原理圖：

比如有如下創(chuàng)建強(qiáng)智能指針的語句：

shared_ptr sp1(new int(10));

則如下所示：

（a）智能指針對(duì)象sp1中主要包括ptr指針指向其管理的資源，ref指針指向該資源的引用計(jì)數(shù)，則顯然會(huì)開辟兩次內(nèi)存。

（b）uses為該資源的強(qiáng)智能指針的引用計(jì)數(shù)，weaks為該資源的弱智能指針的引用計(jì)數(shù)。

3.4.1 shared_ptr

強(qiáng)智能指針。可改變資源的引用計(jì)數(shù)。

（1）強(qiáng)智能指針的交叉引用問題

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指向資源的引用計(jì)數(shù)*/
  cout << pa.use_count() << endl;
  cout << pb.use_count() << endl;
}

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

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

void test07() {
  shared_ptr boy_sptr(new boy());
  weak_ptr boy_wptr(boy_sptr);
  // boy_wptr->study(); 錯(cuò)誤！無法使用弱智能指針訪問資源
  cout << boy_sptr.use_count() << endl; // 引用計(jì)數(shù)為1，因?yàn)槿踔悄苤羔槻桓淖円糜?jì)數(shù)

  shared_ptr i_sptr(new int(99));
  weak_ptr i_wptr(i_sptr);
  // cout << *i_wptr << endl; 錯(cuò)誤！無法使用弱智能指針訪問資源
  cout << i_sptr.use_count() << endl; // 引用計(jì)數(shù)為1，因?yàn)槿踔悄苤羔槻桓淖円糜?jì)數(shù)

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

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

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

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

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

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

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

};

/*子線程執(zhí)行函數(shù)*/
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;
}

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

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

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

};

/*子線程執(zhí)行函數(shù)*/
void threadhandler(weak_ptr pw) {  // 引用時(shí)使用弱智能指針
  this_thread::sleep_for(chrono::seconds(1));
  shared_ptr ps = pw.lock();  // 嘗試提升
  if (ps != nullptr) {
      ps->funcc();
  } else {
      cout << "對(duì)象已經(jīng)析構(gòu)！" << 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;
}

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

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

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

};

/*子線程執(zhí)行函數(shù)*/
void threadhandler(weak_ptr pw) {  // 引用時(shí)使用弱智能指針
  this_thread::sleep_for(chrono::seconds(1));
  shared_ptr ps = pw.lock();  // 嘗試提升
  if (ps != nullptr) {
      ps->funcc();
  } else {
      cout << "對(duì)象已經(jīng)析構(gòu)！" << 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;
}

unique_ptr ptr1(new int[100]);

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

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

void test09() {
  unique_ptr