C++之智能指针

前言

普通指针的不足

new和new门的内存需要用delete和delete[释放。
程序员的主观失误，忘了或漏了释放
程序员也不确定何时释放（例如多个线程共享同一个对象，没办法确定什么时候释放）

普通指针的释放

类内的指针，在析构函数中释放
C++内置数据类型，如何释放?
new出来的类，本身如何释放?

智能指针设计思路

智能指针是类模板，在栈上创建智能指针对象
把普通指针交给智能指针对象
智能指针对象过期时，调用析构函数释放普通指针的内存

什么是智能指针

智能指针是RALL机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。

智能指针详解

unique_ptr

定义：unique_ptr独享它指向的对象，也就是说，同时只有一个unique_ptr指向同一个对象，当这个unique_ptr被销毁时，指向的对象也随即被销毁。

头文件：#include<memory>

template <typename T, typename D = default_delete<T>>
class unique_ptr
{
public:explicit unique_ptr(pointer p) noexcept;    // 不可用于转换函数。~unique_ptr() noexcept;    T& operator*() const;            // 重载*操作符。T* operator->() const noexcept;  // 重载->操作符。unique_ptr(const unique_ptr &) = delete;   // 禁用拷贝构造函数。unique_ptr& operator=(const unique_ptr &) = delete;  // 禁用赋值函数。unique_ptr(unique_ptr &&) noexcept;      // 右值引用。unique_ptr& operator=(unique_ptr &&) noexcept;  // 右值引用。// ...
private:pointer ptr;  // 内置的指针。
};

下面进行测试

#include<memory>
#include<iostream>
#include<vector>
using namespace std;
class AA
{
public:string m_name;AA() { cout << m_name << "调用构造函数AA()。" << endl;}AA(const string& name) : m_name(name) {cout << "调用构造函数AA(" << m_name << ")。" << endl;}~AA() { cout << "调用了析构函数~AA(" << m_name << ")。" << endl;}
};

测试1

void test1()
{AA* p = new AA("张三");//delete p;    //这里结社我们忘记delete
}

运行结果：

调用构造函数AA(张三)。

我们发现出现了内存泄漏问题，这里我们是故意忘记释放，但是真正到了开发时，都有可能会忘记释放，那怎么办呢？我们可以用智能指针unique_ptr

测试2

void test2()
{AA* p = new AA("张三");unique_ptr<AA> p1(p);
}

运行结果

调用构造函数AA(张三)。
张三调用了析构函数~AA(张三)。

我们惊奇的发现我们没有调用delete，但是也调用了析构函数，因为智能指针是一个类，它有析构函数，在析构函数中有delete语句。

并且类重载了->和*，可以像使用普通指针一样使用智能指针

测试3

void test3()
{AA* p = new AA("张三");unique_ptr<AA> p1(p);cout << (*p1).m_name << endl;cout << p1->m_name << endl;cout << p->m_name << endl;cout << (*p).m_name << endl;
}

运行结果

调用构造函数AA(张三)。
张三
张三
张三
张三
张三调用了析构函数~AA(张三)。

基本用法

初始化

//方法1
unique_ptr<AA> p0(new AA("西施"));     // 分配内存并初始化
//方法2
unique_ptr<AA> p0 = make_unique<AA>("西施");   // C++14标准。
unique_ptr<int> pp1=make_unique<int>();         // 数据类型为int。
unique_ptr<AA> pp2 = make_unique<AA>();       // 数据类型为AA，默认构造函数。
unique_ptr<AA> pp3 = make_unique<AA>("西施");  // 数据类型为AA，一个参数的构造函数。
unique_ptr<AA> pp4 = make_unique<AA>("西施",8); // 数据类型为AA，两个参数的构造函数。
//方法3
AA* p = new AA("西施");
unique_ptr<AA> p0(p);                  // 用已存在的地址初始化。

注意：

1. 重载了->和*，可以像使用普通指针一样使用unique_ptr

2. 不支持普通的拷贝和赋值

explicit unique_ptr(pointer p) noexcept; // 因为有explicit，所以不可用于转换函数。
unique_ptr(const unique_ptr &) = delete; // 禁用拷贝构造函数
unique_ptr& operator=(const unique_ptr &) = delete; // 禁用赋值函数。

例如以下测试错误的

void test4()
{AA* p = new AA("张三");unique_ptr<AA> p1 = p;    //错误，不能将普通指针直接复制给智能指针unique_ptr<AA>p2 = new AA("李四");    //错误，不能将普通指针直接复制给智能指针unique_ptr<AA> p3 = pu1;   // 错误，不能用其它unique_ptr拷贝构造unique_ptr<AA> p4;p4=p1;    //错误，不能用=对unique_ptr进行赋值
}

为什么要禁用赋值函数呢？

这个与智能指针实现初衷有关，unique_ptr实现的是一个指针独享一份资源，如果可以复制的话，那个就会出现多个unique_ptr指针指向同一块资源，就会出现非法操作野指针。

3. 不要用同一个裸指针初始化多个unique_ptr对象（也是出现非法操作野指针问题）；

4. 不要用unique_ptr管理不是new分配的内存；

5. get()方法返回裸指针；

6. 用于函数的参数只能传引用；

7. 不支持指针运算（+、-、++、--）。

技巧

1. 将一个unique_ptr赋给另一个时，如果原unique_ptr是一个临时右值，编译器允许这样做；如果源unique_ptr将存在一段时间，编译器禁止这样做。一般用于函数的返回值；
2. 用nullptr给unique_ptr赋值将释放对象，空的unique_ptr==nullptr；
3. release()释放对原始指针的控制权，将unique_ptr置为空，返回裸指针。（可用于把unique_ptr传递给子函数，子函数将负责释放对象）；
4. std::move()可以转移对原始指针的控制权。（可用于把unique_ptr传递给子函数，子函数形参也是unique_ptr）；
5. reset()释放对象；
6. swap()交换两个unique_ptr的控制权；
7. unique_ptr也可象普通指针那样，当指向一个类继承体系的基类对象时，也具有多态性质，如同使用裸指针管理基类对象和派生类对象那样；
8. unique_ptr不是绝对安全，如果程序中调用exit()退出，全局的unique_ptr可以自动释放，但局部的unique_ptr无法释放；
9. unique_ptr提供了支持数组的具体化版本。数组版本的unique_ptr，重载了操作符[]，操作符[]返回的是引用，可以作为左值使用。

这里只演示第1、4、5、8、9；

示例 1：

unique_ptr<AA> func()
{unique_ptr<AA> pp(new AA("小谢"));return pp;
}
void test4()
{unique_ptr<AA> p1(new AA("张三"));unique_ptr<AA> p2;//p2 = p1;p2 = unique_ptr<AA>(new AA("李四"));cout << "调用func之前" << endl;p2 = func();cout << "调用func之后" << endl;
}

示例 4

void func(unique_ptr<AA> a)
{cout << a->m_name << endl;
}
void test5()
{unique_ptr<AA>pu(new AA("张三"));cout << "开始调用函数" << endl;func(move(pu));cout << "调用函数结束" << endl;
}

这里函数调用时使用了move函数，将pu的管理权交给形参

示例 5

void reset(T * _ptr= (T *) nullptr);
pp.reset(); // 释放pp对象指向的资源对象。
pp.reset(nullptr); // 释放pp对象指向的资源对象
pp.reset(new AA("bbb")); // 释放pp指向的资源对象，同时指向新的对象。

示例 8

unique_ptr<AA> p(new AA("全局"));
int main()
{unique_ptr<AA> p1(new AA("局部"));exit(0);
}

结果

调用构造函数AA(全局)。
调用构造函数AA(局部)。
全局调用了析构函数~AA(全局)。

示例 9

unique_ptr<int[]> parr1(new int[3]);          // 不指定初始值。
unique_ptr<int[]> parr1(new int[3]{ 33,22,11 });  // 指定初始值。
cout << "parr1[0]=" << parr1[0] << endl;
cout << "parr1[1]=" << parr1[1] << endl;
cout << "parr1[2]=" << parr1[2] << endl;

shared_ptr

定义：

shared_ptr共享它指向的对象，多个shared_ptr可以指向（关联）相同的对象，在内部采用计数机制来实现。
当新的shared_ptr与对象关联时，引用计数增加1。
当shared_ptr超出作用域时，引用计数减1。当引用计数变为0时，则表示没有任何shared_ptr与对象关联，则释放该对象。

基本用法

初始化

shared_ptr的构造函数也是explicit，但是，没有删除拷贝构造函数和赋值函数。

//方法一：
shared_ptr<AA> p0(new AA("西施"));     // 分配内存并初始化。
//方法二：
shared_ptr<AA> p0 = make_shared<AA>("西施");  // C++11标准，效率更高。
shared_ptr<int> pp1=make_shared<int>();         // 数据类型为int。
shared_ptr<AA> pp2 = make_shared<AA>();       // 数据类型为AA，默认构造函数。
shared_ptr<AA> pp3 = make_shared<AA>("西施");  // 数据类型为AA，一个参数的构造函数。
shared_ptr<AA> pp4 = make_shared<AA>("西施",8); // 数据类型为AA，两个参数的构造函数。
//方法三：
AA* p = new AA("西施");
shared_ptr<AA> p0(p);                  // 用已存在的地址初始化。
//方法四：
shared_ptr<AA> p0(new AA("西施")); 
shared_ptr<AA> p1(p0);                 // 用已存在的shared_ptr初始化，计数加1。
shared_ptr<AA> p1=p0;                 // 用已存在的shared_ptr初始化，计数加1

注意：

1. 智能指针重载了*和->操作符，可以像使用指针一样使用shared_ptr；

2. use_count()方法返回引用计数器的值；

3. unique()方法，如果use_count()为1，返回true，否则返回false

4. shared_ptr支持赋值，左值的shared_ptr的计数器将减1，右值shared_ptr的计算器将加1（当某个资源没有指向时就会被释放）；

5. get()方法返回裸指针；

6. 不要用同一个裸指针初始化多个shared_ptr；

7. 不要用shared_ptr管理不是new分配的内存；

8. 用于函数的参数只能传引用；

9. 不支持指针运算（+、-、++、--）。

技巧

1. 用nullptr给shared_ptr赋值将把计数减1，如果计数为0，将释放对象，空shared_ptr==nullptr；
2. std::move()可以转移对原始指针的控制权。还可以将unique_ptr转移成shared_ptr；
3. reset()改变与资源的关联关系；
pp.reset(); // 解除与资源的关系，资源的引用计数减1。
pp. reset(new AA("bbb")); // 解除与资源的关系，资源的引用计数减1。关联新资源。
4. swap()交换两个shared_ptr的控制权；
void swap(shared_ptr<T> &_Right);
5. shared_ptr也可象普通指针那样，当指向一个类继承体系的基类对象时，也具有多态性质，如同使用裸指针管理基类对象和派生类对象那样；
6. shared_ptr不是绝对安全，如果程序中调用exit()退出，全局的shared_ptr可以自动释放，但局部的shared_ptr无法释放；
7. shared_ptr提供了支持数组的具体化版本；
数组版本的shared_ptr，重载了操作符[]，操作符[]返回的是引用，可以作为左值使用；
8. shared_ptr的线程安全性：
shared_ptr的引用计数本身是线程安全（引用计数是原子操作）。
多个线程同时读同一个shared_ptr对象是线程安全的。
如果是多个线程对同一个shared_ptr对象进行读和写，则需要加锁。
多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护。
9. 如果unique_ptr能解决问题，就不要用shared_ptr。unique_ptr的效率更高，占用的资源更少。

weak_ptr

定义

weak_ptr 是为了配合shared_ptr而引入的，它指向一个由shared_ptr管理的资源但不影响资源的生命周期。也就是说，将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。
不论是否有weak_ptr指向，如果最后一个指向资源的shared_ptr被销毁，资源就会被释放。
weak_ptr更像是shared_ptr的助手而不是智能指针

这里举个例子

#include <iostream>
#include <memory>
using  namespace std;
class BB;
class AA
{
public:string m_name;AA() { cout << m_name << "调用构造函数AA()。\n"; }AA(const string& name) : m_name(name) { cout << "调用构造函数AA(" << m_name << ")。\n"; }~AA() { cout << "调用了析构函数~AA(" << m_name << ")。\n"; }shared_ptr<BB> m_p;
};
class BB
{
public:string m_name;BB() { cout << m_name << "调用构造函数BB()。\n"; }BB(const string& name) : m_name(name) { cout << "调用构造函数BB(" << m_name << ")。\n"; }~BB() { cout << "调用了析构函数~BB(" << m_name << ")。\n"; }shared_ptr<AA> m_p;
};
int main()
{shared_ptr<AA> pa = make_shared<AA>("西施a");shared_ptr<BB> pb = make_shared<BB>("西施b");pa->m_p = pb;pb->m_p = pa;
}

程序结果：

显然AA和BB都没有析构，这是为什么呢？？

AA中有类BB的指针指向pb，BB中有类AA的指针指向pa，所以pa和pb不知道谁先“死”，所以程序没办法判断谁先析构，最后干脆不析构了。

那怎么解决这个问题呢（智能指针的循环引用问题）？这里引出了weak_ptr指针，代码修改如下

基本用法

weak_ptr没有重载 ->和 *操作符，不能直接访问资源。
有以下成员函数：
1）operator=(); // 把shared_ptr或weak_ptr赋值给weak_ptr。
2）expired(); // 判断它指资源是否已过期（已经被销毁）。
3）lock(); // 返回shared_ptr，如果资源已过期，返回空的shared_ptr。
4）reset(); // 将当前weak_ptr指针置为空。
5）swap(); // 交换。
weak_ptr不控制对象的生命周期，但是，它知道对象是否还活着。
用lock()函数把它可以提升为shared_ptr，如果对象还活着，返回有效的shared_ptr，如果对象已经死了，提升会失败，返回一个空的shared_ptr。
提升的行为（lock()）是线程安全的。

进行测试

int main()
{shared_ptr<AA> pa = make_shared<AA>("西施a");{shared_ptr<BB> pb = make_shared<BB>("西施b");pa->m_p = pb;pb->m_p = pa;shared_ptr<BB> pp = pa->m_p.lock();            // 把weak_ptr提升为shared_ptr。if (pp == nullptr)cout << "语句块内部：pa->m_p已过期。\n";elsecout << "语句块内部：pp->m_name=" << pp->m_name << endl;}shared_ptr<BB> pp = pa->m_p.lock();            // 把weak_ptr提升为shared_ptr。if (pp == nullptr)cout << "语句块外部：pa->m_p已过期。\n";elsecout << "语句块外部：pp->m_name=" << pp->m_name << endl;
}

运行结果

删除器

#include <iostream>
#include <memory>
using  namespace std;class AA
{
public:string m_name;AA() { cout << m_name << "调用构造函数AA()。" << endl; }AA(const string& name) : m_name(name) { cout << "调用构造函数AA(" << m_name << ")。" << endl; }~AA() { cout << "调用了析构函数~AA(" << m_name << ")。" << endl; }
};void deletefunc(AA* a) {    // 删除器，普通函数。cout << "自定义删除器（全局函数）。" << endl;delete a;
}struct deleteclass               // 删除器，仿函数。
{void operator()(AA* a) {cout << "自定义删除器（仿函数）。" << endl;delete a;}
};auto deleterlamb = [](AA* a) {   // 删除器，Lambda表达式。cout << "自定义删除器（Lambda）。" << endl;delete a;
};int main()
{shared_ptr<AA> pa1(new AA("张三"));    //不填，默认使用缺省//shared_ptr<AA> pa1(new AA("张三"), deletefunc);//shared_ptr<AA> pa2(new AA("李四"), deleteclass());//shared_ptr<AA> pa3(new AA("王五"), deleterlamb);//unique_ptr<AA,decltype(deletefunc)*> pu1(new AA("张三"), deletefunc);//unique_ptr<AA, void (*)(AA*)> pu0(new AA("李四"), deletefunc);//unique_ptr<AA, deleteclass> pu2(new AA("王五"), deleteclass());//unique_ptr<AA, decltype(deleterlamb)> pu3(new AA("小谢"), deleterlamb);return 0;
}