C++11新增特性：智能指针（RAII）
一、RAII
RAII（Resource Acquisition Is Initialization）,资源获得即初始化，是一种利用对象的生命周期对资源进行管理的简单技术！！对象在构造时获得资源，然后控制着对资源的访问，使之在对象的生命周期内始终有效；对象在析构时对资源进行释放。通过RAII的思想对资源进行管理有两大好处：
- 无需显示释放资源。比如在程序抛异常时，对象析构时对自动释放资源，大大降低了内存泄漏的风险！
- 对象所需的资源在其生命期内始终保持有效。
二、智能指针原理
智能指针是一种通过RAII的思想对动态分配的内资源进行管理，并且具备指针的行为，支持解引用和通过->去访问其指向资源的内容！！在C++的发展史中，一个出现了4种智能指针，依次为auto_ptr、unique_ptr、shared_ptr、weak_ptr（weak_ptr不符合RAII思想，用于对shared_ptr的补贴）
- 接下来所有的指针指针首字母大写，防止各位测试和C++库中对应智能指针冲突！
1）、auto_ptr
在C++98中，提供了名为auto_ptr的智能指针。auto_ptr的原理为：管理权转移！通过auto_ptr对动态分配内存资源进行管理，但如果在使用过程中发生拷贝、赋值等行为时，直接将对资源的管理权转移给新对象！
emmm…，但很多公司明确禁止使用auto_ptr。原理在于auto_ptr会导致对象悬空！
【auto_ptr】实现：
template <class T>
class Auto_ptr
{
public:
Auto_ptr(T* ptr = nullptr) :_ptr(ptr)
{}
~Auto_ptr()
{
if(_ptr)
delete _ptr;
cout << "~Auto_ptr()" << endl; // for test
}
public:
Auto_ptr(Auto_ptr& p)
:_ptr(p._ptr)
{
p._ptr = nullptr;
}
Auto_ptr<T>& operator=(Auto_ptr<T>& ap)
{
if (this != &ap)
{
delete _ptr;
_ptr = ap._ptr;
ap._ptr = nullptr;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
2)、unique_ptr
在C++11中，新增名为unique_ptr的智能指针。和auto_ptr不同的是， unique_ptr直接简单粗暴防拷贝！！
【unique_ptr实现】：
template <class T>
class Unique_ptr
{
public:
Unique_ptr(T* ptr = nullptr) :_ptr(ptr)
{}
~Unique_ptr()
{
delete _ptr;
cout << "~Unique_ptr()" << endl; // for test
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
public:
// C++98实现方式： 只声明不实现 同时访问权限设置为私有
Unique_ptr(const Unique_ptr<T>& up) = delete;
Unique_ptr<T>& operator=(const Unique_ptr<T>& up) = delete;
private:
T* _ptr;
};
3)、shared_ptr
在C++11还提供了更为靠谱的shared_ptr智能指针，并且支持拷贝行为！！
shared_ptr通过引用计数的方式实现多个对象间资源共享！每一个shared_ptr对象内部会维护一把计数器，用来记录该资源被几个对象共享。在shared_ptr对象构造时，引用计数加1；析构时，引用计数减1。但需要主要的时，析构时只有引用计数减为0，也意味着自己是这块资源的最后使用者，此时才能对所管理的资源进行释放！！
但对象构造和析构时都需要会引用计数进行操作。此时多执行并发访问时，可能会导致数据不一致问题！所以我们需要对计数器进行加锁！！
【shared_ptr实现】：由于在拷贝构造、赋值重载以及析构时，都会设计到引用计数++和–，以及引用计数–需要判断释放需要将资源进行释放。所以我们将两者行为单独实现成AddRef() 增加引用计数；Release()减少引用计数（内部会判断是否需要将资源进行释放）（其他详见代码）
template <class T>
class Shared_ptr
{
public:
Shared_ptr(T * ptr = nullptr)
:_ptr(ptr), _Pcount(new std::atomic<int>(1))
{}
Shared_ptr(const Shared_ptr<T>& sp)
:_ptr(sp._ptr), _Pcount(sp._Pcount)
{
(*_Pcount)++;
}
Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
{
if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
{
release(); // 在赋值前，将自身引用计数--
_ptr = sp._ptr;
_Pcount = sp._Pcount;
(*_Pcount)++;
return *this;
}
}
int use_count() const { return _Pcount->load(); }
T* get() const { return _ptr; } // const 防止权限放大
T* operator->() { return _ptr; }
T& operator*() { return *_ptr; }
~Shared_ptr()
{
release();
}
private:
void release()
{
if (--(*_Pcount) == 0)
{
delete _ptr;
delete _Pcount;
}
}
private:
T* _ptr;
std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
};
- 引用计数不能为const int。原因在于每次析构时，当前对象析构，其他对象的引用计数不会–。会导致内存泄漏问题！
- 引用计数不能为static int。静态成员所有类对象共享该类实例化的成员。
- shared_ptr本事是线程安全的，但shared_ptr所指向的资源不是线程安全的
增加定制删除器
template <class T>
class Shared_ptr
{
public:
Shared_ptr(T * ptr = nullptr)
:_ptr(ptr), _Pcount(new std::atomic<int>(1))
{}
Shared_ptr(const Shared_ptr<T>& sp)
:_ptr(sp._ptr), _Pcount(sp._Pcount)
{
(*_Pcount)++;
}
template <class D>
Shared_ptr(const Shared_ptr<T>& sp, D del)
:_ptr(sp._ptr), _Pcount(sp._Pcount), _del(del)
{
(*_Pcount)++;
}
Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
{
if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
{
release(); // 在赋值前，将自身引用计数--
_ptr = sp._ptr;
_Pcount = sp._Pcount;
(*_Pcount)++;
return *this;
}
}
int use_count() const { return _Pcount->load(); }
T* get() const { return _ptr; } // const 防止权限放大
T* operator->() { return _ptr; }
T& operator*() { return *_ptr; }
~Shared_ptr()
{
release();
}
private:
void release()
{
if (--(*_Pcount) == 0)
{
_del(_ptr);
delete _Pcount;
}
}
private:
T* _ptr;
std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};
4）、weak_ptr
1 ( weak_ptr由来和用途
shared_ptr已经非常完美了，但还是存在一些问题。下面是一个链表结构，我们将两块资源分别交给智能指针shared_ptr进行管理，然后在每一块资源中，还存在一个shared_ptr智能指针指向对方资源。此时就会导致循环引用的问题！而weak_ptr就是对shared_ptr进行补贴，解决循环引用的问题！！
.2 ( 循环引用问题
两个或多个 shared_ptr 对象相互持有对方的引用，形成一个闭环，导致它们之间的引用计数永远无法归零，从而造成内存泄漏。
下面这段代码就是一个典型的循环引用l例子！！
struct ListNode
{
int _data;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
~ListNode()
{
cout << "~ListNode()" << endl; // for debug
}
};
int main()
{
shared_ptr<ListNode> n1 = new ListNode;
shared_ptr<ListNode> n2 = new ListNode;
n1->_prev = n2;
n2->_next = n1;
return 0;
}
n1和n2首先会指向给自的资源，此时引用计数为1。但n1内部_prev智能指针和n2指向同一块资源，所以n2的引用计数更新为2。同理，n1的引用计数也更新为2！！
此时，当变量n1和n2分别出作用域时， node1和node2析构，引用计数减到1。
但是_next还指向下一个节点。但是_prev还指向上一个节点。 也就是说n2->_next析构了，n1就释放了; n1->_prev析构了，node2就释放了！
但是_next属于n2的成员，n1释放了，_next才会析构，而n2由_prev管理，_prev属于n1成员，此时就发生了循环引用，谁也不会释放。内存泄漏！！
.3 ( weak_ptr
所以C++11增加了weak_ptr。和传统指针不同的是，weak_ptr不符合RAII，不参与引用计数，仅是对 shared_ptr 所管理对象的一个非拥有性引用，但可以像指针一样使用！！但如果Shared_ptr指向的空间释放，可能会导致野指针。所以实际Weak_ptr会有一个use_count观察Shared_ptr引用计数
template <class T>
class Shared_ptr
{
public:
Shared_ptr(T * ptr = nullptr)
:_ptr(ptr), _Pcount(new std::atomic<int>(1))
{}
Shared_ptr(const Shared_ptr<T>& sp)
:_ptr(sp._ptr), _Pcount(sp._Pcount)
{
(*_Pcount)++;
}
template <class D>
Shared_ptr(const Shared_ptr<T>& sp, D del)
:_ptr(sp._ptr), _Pcount(sp._Pcount), _del(del)
{
(*_Pcount)++;
}
Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
{
if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
{
release(); // 在赋值前，将自身引用计数--
_ptr = sp._ptr;
_Pcount = sp._Pcount;
(*_Pcount)++;
return *this;
}
}
int use_count() const { return _Pcount->load(); }
T* get() const { return _ptr; } // const 防止权限放大
T* operator->() { return _ptr; }
T& operator*() { return *_ptr; }
~Shared_ptr()
{
release();
}
private:
void release()
{
if (--(*_Pcount) == 0)
{
_del(_ptr);
delete _Pcount;
}
}
private:
T* _ptr;
std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};
// 不参与Shared_ptr的引用计数，不支持RAII。
// 但如果Shared_ptr指向的空间释放，可能会导致野指针。
// 所以实际Weak_ptr会有一个use_count观察Shared_ptr引用计数
template <class T>
class Weak_ptr
{
public:
Weak_ptr() :_ptr(nullptr)
{}
Weak_ptr(const Shared_ptr<T>& sp)
:_ptr(sp.get())
{}
Weak_ptr<T>& operator=(const Shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
【使用用例】：
struct ListNode
{
int _data;
Weak_ptr<ListNode> _prev;
Weak_ptr<ListNode> _next;
};
int main()
{
Shared_ptr<ListNode> n1 = new ListNode;
Shared_ptr<ListNode> n2 = new ListNode;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
n1->_next = n2;
n2->_prev = n1;
Shared_ptr<ListNode> n3(new ListNode[10], [](ListNode* ptr) {delete[] ptr; });
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
return 0;
}
三、C++11和boost中智能指针的关系
- 在C++98时，C++出现了第一个智能指针auto_ptr。
- 在99年时，boost成立。并且在C++98和C++11之间，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中的相关智能指针实现的！
扫一扫
1084
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
