C++中的智能指针

Shared_ptr指针

shared_ptr是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数（reference counting）。
一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。

std::shared_ptr pointer(new int(1));

std::shared_ptr pointer1 = pointer;

std::shared_ptrstd::string ss(new std::string(“AAA”));

std::shared_ptrstd::string = std::shared_ptrstd::string(new std::string(“AAA”));

std::shared_ptr p3 = std::make_shared();

std::shared_ptr p2 = std::make_shared(“hello”);

//auto关键字代替std::shared_ptr，p5指向一个动态分配的空vector
auto p5 = make_shared();

#include 
#include 

struct C {int* data;};

int main () {
 auto deleter = [](int*p){
    std::cout << "[deleter called]\n"; delete p;
  };//Labmbda表达式

  std::shared_ptr p1;//默认构造，没有获取任何指针的所有权，引用计数为0
  std::shared_ptr p2 (nullptr);//同1
  std::shared_ptr p3 (new int);//拥有指向int的指针所有权，引用计数为1
  std::shared_ptr p4 (new int, deleter);//作用同3，但是拥有自己的析构方法，如果指针所指向对象为复杂结构C
                                    //结构C里有指针，默认析构函数不会将结构C里的指针data所指向的内存释放,这时需要自己使用自己的析构函数（删除器）
  std::shared_ptr p5 (new int, [](int* p){delete p;}, std::allocator());//同4,但拥有自己的分配器（构造函数），如成员中有指针，可以为指针分配内存，原理跟浅拷贝和深拷贝类似
  std::shared_ptr p6 (p5);//如果p5引用计数为0，则引用计数加1，否则同样为0
  std::shared_ptr p7 (std::move(p6));//获取p6的引用计数，p6引用计数为0
  std::shared_ptr p8 (std::unique_ptr(new int));//p8获取所有权，引用计数设置为1
  std::shared_ptr obj (new C);
  std::shared_ptr p9 (obj, obj->data);//同6一样，只不过拥有自己的删除器与4一样

  std::cout << "use_count:\n";
  std::cout << "p1: " << p1.use_count() << '\n';
  std::cout << "p2: " << p2.use_count() << '\n';
  std::cout << "p3: " << p3.use_count() << '\n';
  std::cout << "p4: " << p4.use_count() << '\n';
  std::cout << "p5: " << p5.use_count() << '\n';
  std::cout << "p6: " << p6.use_count() << '\n';
  std::cout << "p7: " << p7.use_count() << '\n';
  std::cout << "p8: " << p8.use_count() << '\n';
  std::cout << "p9: " << p9.use_count() << '\n';
  return 0;
}

成员函数功能（https://blog.csdn.net/baidu_31541363/article/details/95802210）

1. swap交换内存

     std::shared_ptr foo (new int(10));
     std::shared_ptr bar (new int(20));
   
     foo.swap(bar);//此时foo和bar所指向的内存发生交换
   

C++11智能指针之std::unique_ptr

uniqut_ptr是一种对资源具有排他性拥有权的智能指针，即一个对象资源只能同时被一个unique_ptr

C++11中没有，C++14中才有make_unique，它不支持指定删除器的语法，如果不用删除器，建议优先选择使用，更高的性能。由于我的编译器最高支持C++11，所以没有这个函数。

unique_ptr<int> p1 = make_unique<int>(100);
auto p2 = make_unique<int>(200);

// 示例：
int main() 
{
    unique_ptr<int> pInt(new int(5));
    unique_ptr<int> pInt2 = std::move(pInt);    // 转移所有权
    //cout << *pInt << endl; // 出错，pInt为空
    cout << *pInt2 << endl;
    unique_ptr<int> pInt3(std::move(pInt2));
}

//方法1
unique_ptr p3=unique_ptr(new string(“Hello World”));
//方法2(调用函数返回匿名对象)
unique_ptr return_unique_ptr(string str)
{
//从函数返回一个局部的unique_ptr对象，这种局部对象，系统会给我们再次生
//成一个临时的unique_ptr对象，调用unique_ptr的移动构造函数