C++11（中）：智能指针
智能指针
-
- 1.内存泄漏
-
- 1.1内存泄漏的概念以及危害
- 1.2内存泄漏的场景
- 1.3如何避免内存泄漏
- 2.智能指针的使用及原理
-
- 2.1RAII
- 2.2智能指针的原理
- 2.3 std::auto_ptr
- 2.4 定制删除器
- 2.5 std::unique_ptr
- 2.6 std::shared_ptr
- 2.7 std::weak_ptr
-
- 2.7.1 std::shared_ptr的循环引用
- 2.7.2 循环引用的解决
1.内存泄漏
1.1内存泄漏的概念以及危害
内存泄漏的概念：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
1.2内存泄漏的场景
- 内存申请了忘记释放
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
}
- 异常安全问题，异常会导致执行流乱跳，有可能调用申请了空间，但因为抛出异常而没有得到正常释放，就会导致内存泄漏。
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
int* p1 = new int;
int* p2 = new int;
//div抛出异常，执行流跳到main函数导致p1、p2指向空间未释放
cout << div() << endl;
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
1.3如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
- 使用内存泄漏工具检测。
- 采用RAII思想或者智能指针来管理资源，也是本文重点。
2.智能指针的使用及原理
2.1RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
把获取的资源交给一个对象（栈上的），接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。这种做法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
cout << "资源已释放" << endl;
}
private:
T* _ptr;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try {
Func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
2.2智能指针的原理
- RAII特性
- 重载operator*和opertaor->，可像指针一样使用。
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
struct Date
{
int _year;
int _month;
int _day;
};
int main()
{
SmartPtr<int> sp1(new int);
*sp1 = 10;
cout << *sp1 << endl;
SmartPtr<Date> sparray(new Date);
// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
sparray->_year = 2018;
sparray->_month = 1;
sparray->_day = 1;
}
2.3 std::auto_ptr
C++的各种智能指针不同点在于对于拷贝的处理，因为指针本身是支持拷贝的。
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想。
下面简化模拟实现了一份auto_ptr来了解它的原理：
namespace SmartPtr
{
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
// 管理权转移
sp._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
// 检测是否为自己给自己赋值
if (this != &ap)
{
// 释放当前对象中资源
if (_ptr)
delete _ptr;
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
int main()
{
std::auto_ptr<int> sp1(new int);
std::auto_ptr<int> sp2(sp1); // 管理权转移
// sp1悬空,存在野指针访问
*sp2 = 10;
cout << *sp2 << endl;
cout << *sp1 << endl;
return 0;
}
auto_ptr的总结：
建议别用，泄漏空间程序还不会挂，起码比访问野指针好点。
2.4 定制删除器
交给智能指针管理的资源，有可能是数组，也可能是单个对象，我们需要在析构的时候进行正确的释放，就需要定制删除器。
定制删除器的实现：
- 可用仿函数，仿函数增加对应的模板参数即可。
- 也可用包装器，本文采用的就是包装器。
代码看后面的unique_ptr和shared_ptr，这里写太冗余。
2.5 std::unique_ptr
C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理：
// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace SmartPtr
{
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr = nullptr)
:_ptr(ptr)
{}
~unique_ptr()
{
cout << "release:" << (int*)_ptr << endl; //打印
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
unique_ptr(auto_ptr<T>& up) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
private:
T* _ptr;
};
}
int main()
{
/*bit::unique_ptr sp1(new int);
bit::unique_ptr sp2(sp1);*/
std::unique_ptr<int> sp1(new int);
//std::unique_ptr sp2(sp1);
return 0;
}
unique_ptr的总结：不需要拷贝的情况用。
2.6 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。
拷贝的要点：
- 对标指针，拷贝完看到的应该是同一份资源。
- 直接值拷贝不可行，会多次析构导致崩溃，应该采用引用计数。
引用计数：
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果引用计数不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
namespace SmartPtr
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _count_ptr(new int(1))
{}
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _count_ptr(new int(1))
,_del(del)
{}
shared_ptr(shared_ptr<T>& sp)
{
_ptr = sp._ptr;
_count_ptr = sp._count_ptr;
(*_count_ptr)++; //引用计数加一即可
}
void release()
{
if (--(*_count_ptr) == 0)
{
cout << "release:" << (int*)_ptr << endl; //打印
_del(_ptr);
delete _count_ptr;
_count_ptr = nullptr;
_ptr = nullptr;
}
}
~shared_ptr()
{
release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (sp._ptr != _ptr)
{
release();
_ptr = sp._ptr;
_count_ptr = sp._count_ptr;
(*_count_ptr)++;
}
return *this;
}
T* get() const
{
return _ptr;
}
int use_count() const
{
return *_count_ptr;
}
private:
T* _ptr;
int* _count_ptr;
function<void(T*)> _del = [](T* ptr) { delete[] ptr; };
};
void test_shared_ptr1()
{
shared_ptr<int> sp1 = new int(1);
const shared_ptr<int> sp2 = new int(3);
shared_ptr<int> sp3(new int[10], [](int* ptr) { delete[] ptr; });
//shared_ptr sp3 = sp2;
//sp2 = sp1;
//sp3 = sp1;
}
}
shared_ptr的总结：需要拷贝的情况用。
2.7 std::weak_ptr
2.7.1 std::shared_ptr的循环引用
先看代码，下面代码存在内存泄漏：
struct ListNode
{
int _data;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
};
int main()
{
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
return 0;
}
循环引用分析：
- node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
- node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
- node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
- 也就是说node1的_next析构了，node2就释放了。
- 也就是说node2的_prev析构了，node1就释放了。
- 但是_next属于node1的成员，node1释放了，_next才会析构，而node1由node2成员_prev管理，这就叫循环引用，谁也不会释放。
2.7.2 循环引用的解决
weak_ptr：只负责存储数值，不参与资源管理，支持用shared_ptr构造。
namespace SmartPtr
{
//weak_ptr就如同普通的指针一样，不参与资源的管理
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
weak_ptr<T>& operator=(shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
private:
T* _ptr;
};
}