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中的相关智能指针实现的!