文章目录
-
- 一、智能指针的原理
-
- 二、智能指针的用法
- 1、智能指针的分类
- 2、unique_ptr
-
- 3、shared_ptr
-
- 4、删除器
- 5、weak_ptr
前言
一、智能指针的原理
1、RAII机制
RAII（Resource Acquisition is Initialization），即【资源获取即初始化】，也就是说在构造函数中申请分配资源，在析构函数中释放资源。因为C++的语言机制保证了，当一个对象创建的时候，自动调用构造函数，当对象超出作用域的时候会自动调用析构函数。所以，在RAII的指导下，我们应该使用类来管理资源，将资源和对象的生命周期绑定。
智能指针就是RAII最具代表的实现之一。使用智能指针，可以实现自动的内存管理，再也不需要担心忘记delete造成的内存泄漏。毫不夸张的来讲，有了智能指针，代码中几乎不需要再出现delete了。
2、简单的实现
在了解了RAII机制之后，我们可以尝试实现一个简单的智能指针。
#include <iostream>
using namespace std;
template<class T>
class Smart_ptr
{
private:
T* m_p;
public:
Smart_ptr(T* p = nullptr):m_p(p)
{
cout << "constructor ptr" << endl;
}
~Smart_ptr()
{
if(m_p)
{
cout << "delete ptr" << endl;
delete m_p;
}
}
T& operator*()const {return *m_p;}
T* operator->()const {return m_p;}
};
在上述代码中，我们利用RAII机制，实现了智能指针自动释放资源，又通过重载了operator*和operator->，使其具有和指针一样的行为和功能。
我们可以通过以下的测试用例，观察RAII机制下的智能指针的工作情况：
struct AA
{
int m_a;
AA(int a = 0):m_a(a){cout << "constructor AA" << endl;}
~AA(){cout << "destructor AA" << endl;}
};
int main()
{
{
AA* pa = new AA;
Smart_ptr<AA> sp1(pa);
cout << sp1->m_a << endl;
}
{
Smart_ptr<AA> sp2(new AA(5));
cout << sp2->m_a << endl;
}
{
Smart_ptr<int> sp3(new int(5));
cout << (*sp3) << endl;
}
return 0;
}
运行结果：
constructor AA
constructor ptr
0
delete ptr
destructor AA
constructor AA
constructor ptr
5
delete ptr
destructor AA
constructor ptr
5
delete ptr
二、智能指针的用法
1、智能指针的分类
在C++11中，提供了三种智能指针，接下来我们来逐一了解。使用这些智能指针时需要引用头文件< memory>。
- std::shared_ptr：共享的智能指针
- std::unique_ptr：独占的智能指针
- std::weak_ptr：弱引用的智能指针，它不共享指针，不能操作资源，是用来监视shared_ptr的。
（在C++11之前还有auto_ptr，但由于它并非安全的所以本文不作介绍）
2、unique_ptr
unique_ptr独享它指向的对象，也就是说，同时只有一个unique_ptr指向同一个对象，当这个unique_ptr被销毁时，指向的对象也随即被销毁。
以下是unique_ptr的声明：
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;
};
可以看到，unique_ptr禁用了拷贝构造，也就是说不允许通过赋值将一个unique_ptr赋值给另一个unique_ptr。
基本语法
（1）初始化
unique_ptr的初始化方法和我们实现的智能指针的类似。事实上，我们可以使用以下的方法：
class AA{};
new* pa = new AA;
std::unique_ptr<AA> ptr1(new AA);
std::unique_ptr<AA> ptr1(pa);
std::unique_ptr<AA> ptr2 = move(ptr1);
ptr2.reset(new int);
（2）一些技巧
- 智能指针unique_ptr重载了*和->操作符，使其可以像使用指针一样使用。
- 用nullptr给unique_ptr赋值将释放对象，空的unique_ptr==nullptr。
- 使用get()方法返回原始指针。
- 使用release()释放对原始指针的控制权，将unique_ptr置为空，返回原始指针（可用于把unique_ptr传递给子函数，子函数将负责释放对象）。
- 使用std::move()可以转移对原始指针的控制权（即允许赋值右值，这点在初始化时提起过）。
- 使用reset()释放对象：
1.pp.reset(); // 释放pp对象指向的资源对象
2.pp.reset(nullptr); // 释放pp对象指向的资源对象
3.pp.reset(new AA(“bbb”)); // 释放pp指向的资源对象，同时指向新的对象 - swap()交换两个unique_ptr的控制权。
- 不支持指针的运算（+、-、++、–）。
注意：unique_ptr也不是绝对安全的，如果程序中调用exit()退出，全局的unique_ptr可以自动释放，但局部的unique_ptr无法释放。
unique_ptr还提供了支持数组的具体化版本，使用如下：
unique_ptr<int[]> parr1(new int[3]);
unique_ptr<int[]> parr1(new int[3]{ 33,22,11 });
3、shared_ptr
shared_ptr共享它指向的对象，多个shared_ptr可以指向（关联）相同的对象。在其内部采用计数机制来实现，当新的shared_ptr与对象关联时，引用计数增加1，当shared_ptr超出作用域时，引用计数减1。当引用计数变为0时，则表示没有任何shared_ptr与对象关联，则释放该对象。
基本语法
（1）初始化
和unique_ptr不同的是，shared_ptr没有删除拷贝构造和赋值，并且在C++11标准中可以通过std::make_shared初始化，效率更高（std::make_unique在C++14中才有）。
struct AA{};
shared_ptr<AA> pa0(new AA);
shared_ptr<AA> pa1 = move(pa0);
shared_ptr<AA> pa2 = pa1;
shared_ptr<AA> pa3 = std::make_shared<AA>();
pa0.reset();
pa0.reset(new int);
此外：
- 使用use_count()方法返回引用计数器的值。
- 使用unique()方法，如果use_count()为1，返回true，否则返回false。
- 不要用同一个原始指针初始化多个shared_ptr。
- shared_ptr没有release()函数。
- 其他的函数使用方法和unique_ptr相同。
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"; }
};
int main()
{
shared_ptr<AA> pa0(new AA("aa"));
shared_ptr<AA> pa1 = pa0;
shared_ptr<AA> pa2 = pa0;
cout << "pa0.use_count()=" << pa0.use_count() << endl;
cout << "pa0.get() = " << pa0.get() << endl;
cout << "pa1.get() = " << pa1.get() << endl;
cout << "pa2.get() = " << pa2.get() << endl;
shared_ptr<AA> pb0 = make_shared<AA>("bb");
shared_ptr<AA> pb1 = pb0;
cout << "pb0.use_count()=" << pb0.use_count() << endl;
cout << "pb0.get() = " << pb0.get() << endl;
cout << "pb1.get() = " << pb1.get() << endl;
pb1 = pa1;
pb0 = pa1;
cout << "pa0.use_count()=" << pa0.use_count() << endl;
cout << "pb0.use_count()=" << pb0.use_count() << endl;
}
大家不要误解了共享的含义：shared_ptr指针指向的资源只有一个，它并不是被复制的，而shared_ptr可以有多个。
（2）一些细节
- 用nullptr给shared_ptr赋值将把计数减1，如果计数为0，将释放对象，空的shared_ptr==nullptr。
- std::move()可以转移对原始指针的控制权。还可以将unique_ptr转移成shared_ptr。
- shared_ptr的线程安全性：
1.shared_ptr的引用计数本身是线程安全（引用计数是原子操作）。
2.多个线程同时读同一个shared_ptr对象是线程安全的。
3.如果是多个线程对同一个shared_ptr对象进行读和写，则需要加锁。
4.多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护。
4、删除器
在默认情况下，智能指针过期的时候，用delete原始指针释放它管理的资源，程序员可以自定义删除器，改变智能指针释放资源的行为（旨在释放资源的同时能干点其他事情）。
删除器可以是全局函数、仿函数和Lambda表达式，形参为原始指针：
void deletefunc(AA* a) {
cout << "自定义删除器（全局函数）。\n";
delete a;
}
struct deleteclass
{
void operator()(AA* a) {
cout << "自定义删除器（仿函数）。\n";
delete a;
}
};
auto deleterlamb = [](AA* a) {
cout << "自定义删除器（Lambda）。\n";
delete a;
};
给shared_ptr指定删除器十分简单，写入函数名即可：
shared_ptr<AA> pa1(new AA("aa"), deletefunc);
shared_ptr<AA> pa1(new AA("bb"), deleteclass());
shared_ptr<AA> pa1(new AA("cc"), deleterlamb);
而在unique_ptr中会复杂一些：
unique_ptr<AA,decltype(deletefunc)*> pu1(new AA("aa"), deletefunc);
unique_ptr<AA,void(*)(AA*)> pu1(new AA("aa"), deletefunc);
unique_ptr<AA,deleteclass)> pu1(new AA("bb"), deleteclass());
unique_ptr<AA, decltype(deleterlamb)> pu3(new AA("cc"), deleterlamb);
5、weak_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 << "调用构造函数AA()。\n"; }
BB(const string & name) : m_name(name) { cout << "调用构造函数AA("<< m_name << ")。\n"; }
~BB() { cout << "调用了析构函数~AA(" << m_name << ")。\n"; }
shared_ptr<AA> m_p;
};
int main()
{
shared_ptr<AA> pa = make_shared<AA>("aa");
shared_ptr<BB> pb = make_shared<BB>("bb");
pa->m_p = pb;
pb->m_p = pa;
cout << "pa.use_count()=" << pa.use_count() << endl;
cout << "pb.use_count()=" << pb.use_count() << endl;
return 0;
}
我们会发现shared_ptr的计数器不灵了，因为上述的代码让pa和pb陷入了一个逻辑死区：我等你先死，你等我先死，结果谁都死不了。
为了解决这个问题，C++引入了weak_ptr。weak_ptr 是为了配合shared_ptr而引入的，它指向一个由shared_ptr管理的资源但不影响资源的生命周期。也就是说，将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。
不论是否有weak_ptr指向，如果最后一个指向资源的shared_ptr被销毁，资源就会被释放。
我们将上文代码中的类的成员变量指针替换成weak_ptr，结果就一切正常了，大家可以自己试一试。
使用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应用多在多线程中，对此我们总结weak_ptr的灵魂特性：
- weak_ptr不控制对象的生命周期，但是，它知道对象是否还活着。
- 用lock()函数把它可以提升为shared_ptr，如果对象还活着，返回有效的shared_ptr，如果对象已经死了，提升会失败，返回一个空的shared_ptr。
- 提升的行为（lock()）是线程安全的。
我们可以通过以下的代码应用这3点：
shared_ptr<AA> pa = make_shared<AA>("aa");
{
shared_ptr<BB> pb = make_shared<BB>("bb");
pa->m_p = pb;
pb->m_p = pa;
shared_ptr<BB> pp = pa->m_p.lock();
if (pp == nullptr)
cout << "语句块内部：pa->m_p已过期。\n";
else
cout << "语句块内部：pp->m_name=" << pp->m_name << endl;
}
shared_ptr<BB> pp = pa->m_p.lock();
if (pp == nullptr)
cout << "语句块外部：pa->m_p已过期。\n";
else
cout << "语句块外部：pp->m_name=" << pp->m_name << endl;
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
