从稍微懂一点开始的C++学习之路1： 智能指针

从稍微懂一点开始的C++学习之路1 智能指针

因为之前一直是搞qt的，没有搞过纯c++，所以现在算得上是刚开始学纯C++。C++的大部分语法其实我都懂，主要的是一些规范，还有内存回收等一些细节地方纯C++和Qt之间还是有蛮大差距的，现在底层框架需要用纯C++进行开发，所以这里我就重新学一下C++这门语言。

基础的语法就不再去详细了解了，现在从一些机制开始聊起，看到哪算哪，感觉有意思的就记一下。

今天聊聊智能指针

在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当造成的。比如：

• 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；
• 有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；
• 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。

针对以上这些情况，很多程序员认为 C++ 语言应该提供更友好的内存管理机制，这样就可以将精力集中于开发项目的各个功能上。

C++ 智能指针底层是采用引用计数的方式实现的。简单的理解，智能指针在申请堆内存空间的同时，会为其配备一个整形值（初始值为 1），每当有新对象使用此堆内存时，该整形值 +1；反之，每当使用此堆内存的对象被释放时，该整形值减 1。当堆空间对应的整形值为 0 时，即表明不再有对象使用它，该堆空间就会被释放掉。

注意本文的智能指针需要用到

1. #include <memory>
2. using namespace std

请不要忘记这点

1.shared_ptr

shared_ptr就是可以共享的指针，和 unique_ptr、weak_ptr 不同之处在于，多个 shared_ptr 智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个 shared_ptr 指针放弃了堆内存的“使用权”（引用计数减 1），也不会影响其他指向同一堆内存的 shared_ptr 指针（只有引用计数为 0 时，堆内存才会被自动释放）。

1、shared_ptr智能指针的创建

shared_ptr<T> 类模板中，提供了多种实用的构造函数，这里给读者列举了几个常用的构造函数（以构建指向 int 类型数据的智能指针为例）。

1)  通过如下 2 种方式，可以构造出 shared_ptr<T> 类型的空智能指针：

1. std::shared_ptr<int> p1; //不传入任何实参
2. std::shared_ptr<int> p2(nullptr); //传入空指针 nullptr

注意，空的 shared_ptr 指针，其初始引用计数为 0，而不是 1。

2) 在构建 shared_ptr 智能指针，也可以明确其指向。例如：

1. std::shared_ptr<int> p3(new int(10));

由此，我们就成功构建了一个 shared_ptr 智能指针，其指向一块存有 10 这个 int 类型数据的堆内存空间。

同时，C++11 标准中还提供了 std::make_shared<T> 模板函数，其可以用于初始化 shared_ptr 智能指针，例如：

1. std::shared_ptr<int> p3 = std::make_shared<int>(10);

以上 2 种方式创建的 p3 是完全相同。

3) 除此之外，shared_ptr<T> 模板还提供有相应的拷贝构造函数和移动构造函数，例如：

1. //调用拷贝构造函数
2. std::shared_ptr<int> p4(p3);//或者 std::shared_ptr<int> p4 = p3;
3. //调用移动构造函数
4. std::shared_ptr<int> p5(std::move(p4)); //或者 std::shared_ptr<int> p5 = std::move(p4);

如上所示，p3 和 p4 都是 shared_ptr 类型的智能指针，因此可以用 p3 来初始化 p4，由于 p3 是左值，因此会调用拷贝构造函数。需要注意的是，如果 p3 为空智能指针，则 p4 也为空智能指针，其引用计数初始值为 0；反之，则表明 p4 和 p3 指向同一块堆内存，同时该堆空间的引用计数会加 1。

而对于 std::move(p4) 来说，该函数会强制将 p4 转换成对应的右值，因此初始化 p5 调用的是移动构造函数。另外和调用拷贝构造函数不同，用 std::move(p4) 初始化 p5，会使得 p5 拥有了 p4 的堆内存，而 p4 则变成了空智能指针。

注意，同一普通指针不能同时为多个 shared_ptr 对象赋值，否则会导致程序发生异常。例如：

int* ptr = new int;
std::shared_ptr<int> p1(ptr);
std::shared_ptr<int> p2(ptr);//错误

4) 在初始化 shared_ptr 智能指针时，还可以自定义所指堆内存的释放规则，这样当堆内存的引用计数为 0 时，会优先调用我们自定义的释放规则。

在某些场景中，自定义释放规则是很有必要的。比如，对于申请的动态数组来说，shared_ptr 指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。

对于申请的动态数组，释放规则可以使用 C++11 标准中提供的 default_delete<T> 模板类，我们也可以自定义释放规则：

//指定 default_delete 作为释放规则
std::shared_ptr<int> p6(new int[10], std::default_delete<int[]>());

//自定义释放规则
void deleteInt(int*p) {
    delete []p;
}
//初始化智能指针，并自定义释放规则
std::shared_ptr<int> p7(new int[10], deleteInt);

使用了动态生存期的资源的类：
程序使用动态内存处于以下三种原因：

1.程序不知道自己需要使用多少对象

2.程序不知道所需对象的准确类型

3.程序需要在多个对象间共享数据

在Effective c++中提到，最好是使用这种智能指针！

那我们如果直接管理内存呢！

玩的明白那当然也行，但是很容易发生野指针和空指针的问题，这个还是需要好好斟酌一下，接受新事物并没有什么大不了的，不是吗？

动态内存的管理非常容易出错，也就是使用new 和 delete管理动态内存存在三个常见问题

1.忘记delete内存。忘记释放动态内存会导致人们常说的内存泄漏问题，因为这种内存被占用后指针就丢失了，被占用的内存就永远不可能归还给自由空间了。查找内存泄漏错误是非常困难的，因为一般引用程序都是在运行了很长事件之后，真正耗尽内存的时候才会检测到这种错误。

2.使用已经释放掉的对象，通过释放内存后将指针置空，有时候可以检测到这种错误。

3.同一块内存释放两次。当有两恶搞指针指向相同的动态分配对象时，可能发生这种错误。如果对其中一个指针进行了delete操作，对象的内存就被归还给自由空间了。如果我们在delete第二次，就会破坏空指针的内存，自由空间就可能被破坏。

查找和维护这些错误是非常困难的，所以尽量多使用只能指针。

坚持只是用智能指针，就可以避免所有问题。对于一块内存，只有在没有任何智能指针指向它的情况下，智能指针才会自动释放它。

delete之后重置指针值？

delete之后，指针就变成空悬指针了！就是一块曾经有数据，但是现在是空白内存的指针。而且这个还不好排查，因为这个空悬指针可能还不是nullptr，没有办法检查。

解决办法如果这个指针在很多地方被使用了的话，delete这个指针的时候还需要将这个指针置为nullptr,这样就可以方便找出空悬指针了（当然了vs的debug很容易看得出空悬指针，但毕竟程序里也需要判断嘛)

但是重置指针只提供了有限的保护，约等于没有保护

如果多个指针指向相同的内存，在delete内存之后重置指针的方法只对这个指针有效。

比如我们有个A和B两个指针，是指向相同的内存，我们现在释放A之后，B的内存相当于也被释放掉了。

这个时候我们会将A置为 nullptr，确实是保护了A，但问题是B 现在的内存也被清理掉了，相当于是凭空产生了B这么个空悬指针，没有置为 nullptr。

但问题是我们有时候会有很多指针共享内存，我怎么知道谁被释放了谁没被释放？指针多了，这就是很难控制的了。

不要将普通指针和智能指针混用

准确的说不是不让混用，是不让你拿普通指针来生成临时的智能指针，可能会导致一些无法预料的错误，来看两段简单的代码。

假设我们有一个函数，是这样的

void test(shared_ptr<int> t1)
{
　　//用到t1
}
//函数结束，参数t1被释放，t1的计数减一

正常来说，我们是这样调用函数的
shared_ptr<int> int_t(new int(1234)); //此处计数为1

test(int_t); //在函数内部，此int_t的计数为2，函数结束了之后，int_t的计数就变为了1

int i = *int_t; //正确的，此时int_t的计数为1

如果我们混用，会发生什么？

int *normal_ptr(new int(1234)); //一个普通指针

//process(normal_ptr) //错误，int*无法转换成一个shared_ptr

process(shared_ptr<int>(normal_ptr)); //这是合法的，但是在process函数内部，这个智能指针的计数为一，函数结束之后，智能指针的计数为0，并且将normal_ptr释放了

int j = *x; //此时的x是一个空悬指针，这样调用会导致意想不到的错误。

这个例子就将混用的危害显而易见的标识了

当shared_ptr绑定到一个普通指针时，内存的管理职责交给shared_ptr就行了。一旦我们这么做了，就不应该再用内置的指针来访为 shared_ptr所指向 的内存了。