关于C++智能指针复习总结

RAII(Resource Acquisition Is Initialization): 资源获得即初始化

利用对象生命周期来控制程序的资源(将资源交给对象处理) 智能指针利用了该思想

• 将资源交给一个对象, 初始化资源(可以是指针或者等等资源), 释放交给析构函数
  因为析构函数无论是什么场景, 对象销毁时一定会被调用, 故此资源一定会被释放

智能指针

使用了RAII的思想管理动态内存分配的一个工具，以减少内存泄露的风险。
在使用上像一个普通指针一样操作(*和->)

头文件<memory.h>

auto_ptr（C++11及以后已被弃用）

• 拷贝→ 资源管理权转移(会导致原拷贝对象悬空)
  即将原先的智能指针内容转换到新的智能指针内
• 该智能指针属于一个反面教材

template<typename T>  
class auto_ptr {  T* ptr;  
public:  explicit auto_ptr(T* p = nullptr) : ptr(p) {}  ~auto_ptr() { delete ptr; }  auto_ptr(const auto_ptr& other) : ptr(other.ptr) {  other.ptr = nullptr; // 所有权转移！这是有问题的部分。  }  auto_ptr& operator=(const auto_ptr& other) {  if (this != &other) {  delete ptr; // 删除当前对象所拥有的资源  ptr = other.ptr; // 获取新资源的所有权  other.ptr = nullptr; // 将原所有者的指针设为 nullptr  }  return *this;  }  T& operator*() const { return *ptr; }  T* operator->() const { return ptr; }  
};

unique_ptr

一个智能指针只能管理一个指针对象(不支持赋值和拷贝)

• 从类的语法角度将拷贝构造和赋值用delete关键字删除, 使得无法复制
• 并没有从根上解决auto_ptr的问题

template<typename T>  
class unique_ptr {  T* ptr;  
public:  unique_ptr(T* p = nullptr) : ptr(p) {}  ~unique_ptr() { delete ptr; }  // 手动禁止拷贝和赋值unique_ptr(const unique_ptr& other) = delete;  unique_ptr& operator=(const unique_ptr& other) = delete;  // 移动构造和赋值unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) {  other.ptr = nullptr;  }  unique_ptr& operator=(unique_ptr&& other) noexcept {  if (this != &other) {  delete ptr;  ptr = other.ptr;  other.ptr = nullptr;  }  return *this;  }  T& operator*() const { return *ptr; }  T* operator->() const { return ptr; }  explicit operator bool() const { return ptr != nullptr; }  
};

shared_ptr

可以表示用多个智能指针管理同一个指针对象(支持赋值和拷贝)

• 使用引用计数来实现

  • 每个对象生成时计数++
  • 对象释放时计数–
  • 计数为0时则释放所管理的资源

• 实现shared_ptr

  • 不能使用静态成员变量, 如此静态成员变量是属于整个类, 所有的智能指针对象都会共享该计数(我们应该不同的智能指针对象拥有不同的计数)

  • 应在shared_ptr中添加一个计数指针(指针保存的为地址, 可以在不同对象内传递)在构造中初始化为1, 拷贝时将计数也拷贝+1,在析构时将对应的计数指针–即可

  template<typename T>  
  class shared_ptr {  T* ptr;  int* count;  
  public:  shared_ptr(T* p = nullptr) : ptr(p), count(new int(1)) {}  shared_ptr(const shared_ptr& other) : ptr(other.ptr), count(other.count) {  ++(*count);  }  ~shared_ptr() {  if (--(*count) == 0) {  delete ptr;  delete count;  }  }  shared_ptr& operator=(const shared_ptr& other) {  if (this != &other) {  if (--(*count) == 0) {  delete ptr;  delete count;  }  ptr = other.ptr;  count = other.count;  ++(*count);  }  return *this;  }  T& operator*() const { return *ptr; }  T* operator->() const { return ptr; }  
  };
  

shared_ptr的问题

• 循环引用(无法在内部解决), 需要使用weak_ptr解决
  weak_ptr主要用shared_ptr构造, 用于解决循环引用问题

  1. 当一个自定义类型内也存在多个shared_ptr时, 两个及以上个自定义类型通过shared_ptr互相指向时则会出现循环引用的问题
  2. weak_ptr不会增加对应shared_ptr的引用计数(即不参与资源管理)
     但是仍旧可以像指针一样使用weak_ptr(可以访问和修改资源)

  struct Node
  {int _val;//成员包含shared_ptr类型, 去管理其它对象时会对应增加计数/*std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;*///管理其它对象时不会增加对应计数std::weak_ptr<Node> _next;std::weak_ptr<Node> _prev;~Node(){cout << "~Node" << endl;}
  };// 循环引用 -- weak_ptr不是常规智能指针，没有RAII，不支持直接管理资源
  // weak_ptr主要用shared_ptr构造，用来解决shared_ptr循环引用问题
  void test_shared_ptr2()
  {/*std::shared_ptr<Node> n1(new Node);std::shared_ptr<Node> n2(new Node);//通过成员进行了相互引用, 则彼此"缠绕"了起来//n1的_next释放需要依赖指针类型的析构, 结点的析构需要依赖所在对象的析构, 但所在对象的析构又依赖于n2的_prev的析构(当_prev析构了, node1才会被析构); 反之类似, 故彼此缠绕, 形成循环引用n1->_next = n2;//增加了node2的计数n2->_prev = n1;//增加了node1的计数*/std::shared_ptr<Node> n1(new Node);std::shared_ptr<Node> n2(new Node);cout << n1.use_count() << endl;cout << n2.use_count() << endl;n1->_next = n2;n2->_prev = n1;cout << n1.use_count() << endl;cout << n2.use_count() << endl;
  }
  

weak_ptr

一般都作为shared_ptr的辅助指针, 解决其循环引用的问题, 它只会指向资源, 而不参与管理资源(即不会增加引用计数)

删除器

关于new和new[]生成的指针对应delete和delete[]的问题(是否匹配使用, 释放空间)

• 为什么存在删除器 ?
  • new和new[]底层都是调用了operator new函数, 然后调用了malloc以及对应对象的构造函数,但区别在于new[]在malloc时多malloc了4个字节存在首部(用于delete[]时对应找到malloc了多少个对象空间)
  • delete和delete[]底层都是调用了operator delete, 然后调用了对应对象的析构和free,区别在于delete调用了一次析构和一次free, 但delete[]调用了n次析构和1次free
    但在析构时,指针会往前偏移4个字节找到总构造的对象个数所对应的空间, 然后依次调用析构和free
  • 如果是new[]出来的对象使用delete释放时, 由于delete不会进行偏移, 会导致free的位置不正确, 导致程序崩溃
• 定制删除器
  • 仿函数
  • lambda表达式
  • 不同的智能指针对应的删除器
    • shared_ptr可在构造函数内传入仿函数或者lambda表达式
    • unique_ptr只能从模板参数传入