C++ 常用的三个智能指针

 1.什么是智能指针

 在 C++中，内存的分配与释放都是由开发者手动进行实现的。虽然说这种方式很灵活，但是也很容易出错，比如说忘记了释放内存或者多次释放内存等等。为了避免这样的问题，C++便引入了智能指针这个概念。智能指针是一种类，它在析构时自动释放所管理的对象所占用的内存。这样，程序员就不需要手动管理内存，减少了出错的可能性。智能指针是一种RAII（Resource Acquisition Is Initialization）技术的应用。

RAII的基本思想是：在对象的构造函数中进行资源的分配，在析构函数中进行资源的释放。智能指针也是这种思想的一种扩展，它在析构时自动释放资源。

c++11引入的三种智能指针smart point：
1.std::unique_ptr   独占指针
2.std::shared_ptr   计数指针
3.std::weak_ptr     计数指针的补充

注：std::auto_ptr已经被废弃两个智能指针相互赋值 ，后者丧失所有权，如果再使用后者会报错， 
unique_ptr使用这样的语法编译器会报错

2.C++中的几种智能指针功能特点

2.1 unique_ptr

unique_ptr是一个独享所有权的智能指针，不能共享所有权。当unique_ptr被销毁时，它所管理的对象的内存也会被自动释放。unique_ptr也可以通过std::move()转移所有权。unique_ptr使用的方法很简单，只需要将所需管理的对象传递给unique_ptr即可。

注：这里所说的不能将所有权从一个 unique_ptr 转移到另一个 unique_ptr。意思是不能复制 unique_ptr。

 #include <iostream>
 #include <memory>
 
 int main() {
     // 使用unique_ptr管理int类型的对象
     std::unique_ptr<int> up1(new int(10));
     std::cout << "up1: " << *up1 << std::endl;
 
     // 使用make_unique函数创建unique_ptr对象
     auto up2 = std::make_unique<int>(20);
     std::cout << "up2: " << *up2 << std::endl;
 
     // unique_ptr可以通过std::move()转移所有权
     std::unique_ptr<int> up3 = std::move(up1);
     std::cout << "up3: " << *up3 << std::endl;
 
     return 0;
 }

2.2 shared_ptr

定义：

又称计数指针或共享指针，与unique_ptr不同的是它是可以共享数据的。可以有多个shared_ptr指向同一个对象。每当一个shared_ptr被销毁时，它所管理的对象的引用计数会减 1。当引用计数为 0 时，对象的内存也会被自动释放。

shared_ptr的使用方法和unique_ptr类似，只需要将所需管理的对象传递给shared_ptr即可。需要注意的是，shared_ptr不能管理动态分配的数组，因为它无法确定数组的长度。

说明：

每个 shared_ptr 对象在内部指向两个内存位置：

1、指向对象的指针。

2、用于控制引用计数数据的指针。

shared_ptr原理：shared_ptr创建了一个计数器与类对象所指的内存相关联，copy则计数器加1，销毁则计数器减1，api为use_count()。

共享所有权如何在参考计数的帮助下工作：

1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。

2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。

注：shared_ptr：C++11，共享式指针。多个指针指向同一个对象，最后一个指针被销毁时，这个对象会被释放。

辅助理解： 

 案例代码

 #include <iostream>
 #include <memory>
 int main() {
     // 使用shared_ptr管理int类型的对象
     std::shared_ptr<int> sp1(new int(10));
     std::cout << "sp1: " << *sp1 << std::endl;
     // 使用make_shared函数创建shared_ptr对象
     auto sp2 = std::make_shared<int>(20);
     std::cout << "sp2: " << *sp2 << std::endl;
     // 可以有多个shared_ptr指向同一个对象
     std::shared_ptr<int> sp3 = sp1;
     std::cout << "sp1 count: " << sp1.use_count() << std::endl;
     std::cout << "sp3 count: " << sp3.use_count() << std::endl;
     return 0;
 }

案例测试：

//问题1: p0的引用计数为多少？
shared_ptr<int> p0(nullptr);
cout<<"p0.use_count="<<p0.use_count()<<endl;
//答案 0 ，构造函数初始化,构造空智能指针，引用计数为0

//问题2:请问p1的引用计数为多少？
shared_ptr<int> p1(new int(5));
cout<<"p1.use_cout="<<p1.use_count()<<endl;
//答案 1 ，构造函数初始化,指向一个存有5这个int类型数据的堆内存空间,此时引用计数为1

// 问题3：请问p3的引用计数为多少？
shared_ptr<int> p3(p0);
cout << "p3.use_cout = " << p3.use_count() << endl;
//答案 0 ，P0为空，则P3也为空，其引用计数依然为0

//问题1：请问p1和p3的引用计数为多少？
std::shared_ptr<int> p1(new int(5));
std::shared_ptr<int> p2(p1);
std::shared_ptr<int> p3 = p1;
cout << "p1.use_cout=" << p1.use_count() << endl;
cout << "p3.use_cout=" << p3.use_count() << endl;
//  答案： p1=3 p2=3

问题2：
shared_ptr<int>p0(nullptr);
cout << "p0.use_cout=" << p0.use_count() << endl;
	
int *p4 = new int;
p4 = nullptr;
shared_ptr<int> p5(p4);
shared_ptr<int>p6(p5);
shared_ptr<int>p7(p4);

cout << "p5.use_cout=" << p5.use_count() << endl;
cout << "p6.use_cout=" << p6.use_count() << endl;
cout << "p7.use_cout=" << p7.use_count() << endl;
//答案 0 2 2 1 ,注意nullptr和 指针构造方式不同，传入nullptr计数为0,(具体可以复制代码到编译器跳转到函数声明里的构造看)

 易错点： 

//错误赋值方式
shared_ptr<int> p1=new int(5);	

 Reset 函数

1.重置当前存储的指针

2.reset 初始化  它将引用计数减少1，如果引用计数变为0，则删除指针。

cout << "reset 初始化" << endl;
shared_ptr<int> p7(new int(20));
shared_ptr<int> p8(p7);
shared_ptr<int> p9(p7);
cout << "p7.use_count = " << p7.use_count() << endl;
cout << "p8.use_count = " << p8.use_count() << endl;
cout << "p9.use_count = " << p9.use_count() << endl;	
cout << " " << endl;

p9.reset();
cout << "p7.use_count = " << p7.use_count() << endl;
cout << "p8.use_count = " << p8.use_count() << endl;
cout << "p9.use_count = " << p9.use_count() << endl;
cout << " " << endl;

p7.reset(new int(21));
cout << "p7.use_count = " << p7.use_count() << endl;
cout << "p8.use_count = " << p8.use_count() << endl;
cout << "p9.use_count = " << p9.use_count() << endl;
cout << " " << endl;

p8.reset();
cout << "p7.use_count = " << p7.use_count() << endl;
cout << "p8.use_count = " << p8.use_count() << endl;
cout << "p9.use_count = " << p9.use_count() << endl;
cout << " " << endl;

//答案：
reset 初始化
p7.use_count = 3
p8.use_count = 3
p9.use_count = 3

p7.use_count = 2
p8.use_count = 2
p9.use_count = 0

p7.use_count = 1
p8.use_count = 1
p9.use_count = 0

p7.use_count = 1
p8.use_count = 0
p9.use_count = 0

 2.3 weak_ptr

weak_ptr是一个弱引用的智能指针，它可以与shared_ptr一起使用。weak_ptr不会增加所管理的对象的引用计数，因此它不会影响对象的生命周期。可以通过weak_ptr的lock()成员函数来获取一个指向所管理的对象的shared_ptr。需要注意的是，在使用lock()函数之前，需要判断weak_ptr是否已经过期，即判断其指向的对象是否已经被销毁。

#include <iostream>
#include <memory>
int main() {
// 使用shared_ptr管理int类型的对象
std::shared_ptr<int> sp1(new int(10));
std::weak_ptr<int> wp1 = sp1;
// 判断wp1是否过期
if (auto sp2 = wp1.lock()) {
   std::cout << "wp1: " << *sp2 << std::endl;
} else {
         std::cout << "wp1 expired" << std::endl;
     }
// 销毁sp1
sp1.reset();
// 判断wp1是否过期
if (auto sp2 = wp1.lock()) {
      std::cout << "wp1: " << *sp2 << std::endl;
  } else {
         std::cout << "wp1 expired" << std::endl;
  }
    return 0;
}

拓展 shared_array

定义与差别

它和shared_ptr类似，它包装了new[]操作符在堆上分配的动态数组，也是采用了引用计数的机制。shared_array的接口和功能与shared_ptr几乎是相同的，主要区别：

  (1)、接受指针p必须是new []的结果

  (2)、提供operator[]的重载，可以使用下标

  (3)、系统没有提供*、->的重载

  (4)、析构函数使用delete  [];

 项目用法实例

共同点：

这里的共同点是三个智能指针都可以用到的共有的函数 

get()函数 

 get函数，表示返回当前存储的指针（就是被shared_ptr所管理的指针） 

//int *p = p5;      // 不可以直接赋值
int *p = p5.get();  // 可以
cout << p << endl;  //0018ACC4
cout << p5 << endl; //0018ACC4
cout << p5.get() << endl;//0018ACC4
cout << *p5.get() << endl; //10 //operator*，表示返回对存储指针指向的对象的引用。它相当于：* get（）。
cout << "" << endl;

 初始化方式：（推荐）  

std::make_unique 初始化（推荐使用这种方式来创建智能指针），同理 

std::make_shared 初始化

std::make_weak_ptr初始化

//下面以std::make_shared 初始化为例：
cout << "make_shared 初始化" << endl;
shared_ptr<int> p4 = make_shared<int>();   //定义一个空的智能指针
shared_ptr<int> p5 = make_shared<int>(10); //创建智能指针，并明确指向
auto p6 = make_shared<vector<int>>();      //3.auto关键字代替std::shared_ptr，p6指向一个动态分配的空vector<int>
cout << "" << endl;

知识点注意项

在使用智能指针时，需要注意以下几点：

• 不要将普通指针和智能指针混用，避免重复释放内存或内存泄漏。

• 不要将同一个对象交给不同的智能指针管理，避免引用计数出现错误。

• shared_ptr不能管理动态分配的数组，因为它无法确定数组的长度。

• 在使用weak_ptr的lock()函数之前，需要判断weak_ptr是否已经过期，即判断其指向的对象是否已经被销毁