智能指针
为什么需要智能指针?
为了更好的解决 内存泄漏 所以出现了智能指针
- 当我们malloc出来的内存没有去释放时就会出现问题，就会存在内存泄漏问题。
- 异常安全问题：如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。
- 当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露（没有将基类的析构函数定义为虚函数）
内存泄漏
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
void MemoryLeaks(){
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}
内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏:
- 堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new等 从堆中分配的一块内存，用完后必须通过调用相应的 free 或者 delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄漏
指程序使用系统分配的资源，比方 套接字、文件描述符、管道等 没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱，或者收费昂贵。
智能指针的使用及原理
- RAII（资源获取就是初始化）
RAII(Resource Acquisition Is Initialization)是一种 利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处:
- 不需要显式地释放资源。
- 对象所需的资源在其生命期内始终保持有效。
#include <iostream>
#include <vector>
using namespace std;
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr(){
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
// 将tmp指针委托给了sp对象，相当给tmp指针找了一个可怕的女朋友!天天管着你，直到你go die^^
SmartPtr<int> sp(tmp);
// _MergeSort(a, 0, n - 1, tmp);
// 这里假设处理了一些其他逻辑
vector<int> v(1000000000, 10);
// ...
}
int main() {
try {
int a[5] = { 4, 5, 2, 3, 1 };
MergeSort(a, 5);
}
catch (const exception& e)
{
cout << e.what() << endl; // bad allocation
}
return 0;
}
智能指针的原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此: AutoPtr模板类中还得需要将 * 、->重载下，才可让其像指针一样去使用。
template <class T>
class smart_ptr
{
T* m_ptr;
public:
smart_ptr(T* ptr = nullptr)
: m_ptr(ptr)
{}
~smart_ptr(){
if (m_ptr){
delete[] m_ptr;
m_ptr = nullptr;
}
}
T& operator *(){
return *m_ptr;
}
T* operator ->(){
return m_ptr;
}
T& operator [](int i){
return m_ptr[i];
}
};
class Test
{
public:
int m_a;
};
std::auto_ptr(C++98)
auto_ptr的实现原理：管理权转移的思想
#include <iostream>
#include <memory> // C++库中的智能指针都定义在memory这个头文件中
using namespace std;
class Test
{
public:
int m_a;
};
int main()
{
auto_ptr<int> ap(new int);
auto_ptr<Test> apt(new Test);
*ap = 5;
apt->m_a = 6;
cout << *ap << ' ' << apt->m_a << endl;
auto_ptr<int> ap2 = ap;
cout << *ap2 << ' ' << apt->m_a << endl;
return 0;
}
auto_ptr的实现：
template<class T>
class AutoPtr
{
public:
AutoPtr(T* ptr = NULL)
: _ptr(ptr)
{}
~AutoPtr() {
if (_ptr)
delete _ptr;
}
// 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
// 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
AutoPtr(AutoPtr<T>& ap)
: _ptr(ap._ptr)
{
ap._ptr = NULL;
}
AutoPtr<T>& operator=(AutoPtr<T>& ap)
{
// 检测是否为自己给自己赋值
if(this != &ap)
{
// 释放当前对象中资源
if(_ptr){
delete _ptr;
}
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
std::unique_ptr(C++11)
unique_ptr的设计思路非常的粗暴：防拷贝，也就是不让拷贝和赋值
#include <iostream>
#include <memory>
using namespace std;
class Test
{
public:
int m_a;
};
int main()
{
unique_ptr<int> ap(new int);
unique_ptr<Test> apt(new Test);
*ap = 5;
apt->m_a = 6;
cout << *ap << ' ' << apt->m_a << endl;
// unique_ptr<int> ap2 = ap;
// cout << *ap2 << ' ' << apt->m_a << endl;
return 0;
}
unique_ptr的实现：
template<class T>
class UniquePtr
{
public:
UniquePtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~UniquePtr()
{
if (_ptr)
delete _ptr;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
// C++98防拷贝的方式：只声明不实现+声明成私有
//UniquePtr(UniquePtr<T> const &);
//UniquePtr & operator=(UniquePtr<T> const&);
// C++11防拷贝的方式:delete
UniquePtr(UniquePtr<T> const&) = delete;
UniquePtr& operator=(UniquePtr<T> const&) = delete;
T* _ptr;
};
std::shared_ptr(C++11)
shared_ptr：通过引用计数支持智能指针对象的拷贝
#include <iostream>
#include <memory>
using namespace std;
class Date
{
public:
Date() { cout << "Date()" << endl; }
~Date() { cout << "~Date()" << endl; }
int _year;
int _month;
int _day;
};
int main() {
shared_ptr<Date> sp(new Date);
shared_ptr<Date> copy(sp);
cout << "ref count:" << sp.use_count() << endl;
cout << "ref count:" << copy.use_count() << endl;
return 0;
}
//Date()
//ref count : 2
//ref count : 2
//~Date()
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
-
shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
-
在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
-
如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源;
-
如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
#include <iostream>
#include <memory>
using namespace std;
struct ListNode
{
int _data;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
cout << node1.use_count() << endl; // 1
cout << node2.use_count() << endl; // 1
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl; // 2
cout << node2.use_count() << endl; // 2
return 0;
}
循环引用分析:
-
node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
-
node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
-
node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
-
也就是说_next析构了，node2就释放了。
-
也就是说_prev析构了，node1就释放了。
-
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。
#include <iostream>
#include <memory>
using namespace std;
// 解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
// 原理就是，node1->_next = node2;和node2->_prev = node1;时
// weak_ptr的_next和_prev不会增加 node1和node2的引用计数。
struct ListNode
{
int _data;
weak_ptr<ListNode> _prev;
weak_ptr<ListNode> _next;
~ListNode() { cout << "~ListNode()" << endl; }
};
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;
}
//1
//1
//1
//1
//~ListNode()
//~ListNode()
如果不是new出来的对象如何通过智能指针管理呢?其实shared_ptr设计了一个删除器来解决这个问题
#include <iostream>
using namespace std;
// 仿函数的删除器
template<class T>
struct FreeFunc {
void operator()(T* ptr)
{
cout << "free:" << ptr << endl;
free(ptr);
}
};
template<class T>
struct DeleteArrayFunc {
void operator()(T* ptr)
{
cout << "delete[]" << ptr << endl;
delete[] ptr;
}
};
int main() {
FreeFunc<int> freeFunc;
shared_ptr<int> sp1((int*)malloc(4), freeFunc);
DeleteArrayFunc<int> deleteArrayFunc;
shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
return 0;
}
//delete[]007904D0
//free : 00795108
C++11和boost中智能指针的关系
-
C++ 98 中产生了第一个智能指针auto_ptr.
-
C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
-
C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
-
C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
要点总结
当一个函数中出现大量的return，那么在每一次return前都要加入delete，这种操作非常麻烦且容易出错，智能指针就是用来解决这种问题的。
智能指针是一个类模板，主要功能是假装自己是一个指针，通过析构函数，解决上面的问题。
智能指针就是用来更加方便、安全的使用临时new出来的变量或对象的。
- auto_ptr (※C++98支持，已经废止，尽量不要使用)
- unique_ptr
- shared_ptr
三种指针在拷贝时有区别：
- auto_ptr的拷贝是旧的给新的，旧的失效
- unique_ptr不允许创建新的
- shared_ptr随意拷贝
- weak_ptr解决shared_ptr循环引用的问题
智能指针指向的类型里，包含同样类型的智能指针（类似链表），在这种情况下，如果像链表那样赋值，就会产生这个问题。
特点：啥都没有，只能保存指针值。
删除器：
构造的第二个参数可以传一个仿函数，代表析构的方式。
扫一扫
2537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
