source: http://wang020612.blog.163.com/blog/static/59821429201161791071/
shared_ptr
编辑本段简介
shared_ptr是一种 智能指针(smart pointer)。编辑本段作用
shared_ptr的作用有如内指针,但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数(reference counting)。一旦最后一个这样的指针被销毁,也就是一旦某个对象的引用计数变为0,这个对象会被自动删除。这在非环形数据结构中防止资源泄露很有 帮助。编辑本段历史
shared_ptr最初实现于 Boost库中,后来被C++标准委员会收录于TR1技术报告中,成为 C++0x的一部分。=============================================================================================================
=============================================================================================================
boost::scoped_ptr虽然简单易用,但它不能共享所有权的特性却大大限制了其使用范围,而 boost::shared_ptr可以解决这一局限。顾名思义,boost::shared_ptr是可以共享所有权的智能指针,首先让我们通过一个例子看看它的基本用法:
#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
class implementation
{
public:
~implementation() { std::cout <<"destroying implementation\n"; }
void do_something() { std::cout << "did something\n"; }
};
void test()
{
boost::shared_ptr<implementation> sp1(new implementation());
std::cout<<"The Sample now has "<<sp1.use_count()<<" references\n";
boost::shared_ptr<implementation> sp2 = sp1;
std::cout<<"The Sample now has "<<sp2.use_count()<<" references\n";
sp1.reset();
std::cout<<"After Reset sp1. The Sample now has "<<sp2.use_count()<<" references\n";
sp2.reset();
std::cout<<"After Reset sp2.\n";
}
void main()
{
test();
}
该程序的输出结果如下:
The Sample now has 1 references
The Sample now has 2 references
After Reset sp1. The Sample now has 1 references
destroying implementation
After Reset sp2.
可以看到,boost::shared_ptr指针sp1和sp2同时拥有了implementation对象的访问权限,且当sp1和sp2都释放对该对象的所有权时,其所管理的的对象的内存才被自动释放。在共享对象的访问权限同时,也实现了其内存的自动管理。
boost::shared_ptr的内存管理机制:
boost::shared_ptr的管理机制其实并不复杂,就是对所管理的对象进行了引用计数,当新增一个 boost::shared_ptr对该对象进行管理时,就将该对象的引用计数加一;减少一个boost::shared_ptr对该对象进行管理时,就 将该对象的引用计数减一,如果该对象的引用计数为0的时候,说明没有任何指针对其管理,才调用delete释放其所占的内存。
上面的那个例子可以的图示如下:
-
sp1对implementation对象进行管理,其引用计数为1
-
增加sp2对implementation对象进行管理,其引用计数增加为2
-
sp1释放对implementation对象进行管理,其引用计数变为1
-
sp2释放对implementation对象进行管理,其引用计数变为0,该对象被自动删除
boost::shared_ptr的特点:
和前面介绍的boost::scoped_ptr相比,boost::shared_ptr可以共享对象的所有权,因此其使用范围基本上 没有什么限制(还是有一些需要遵循的使用规则,下文中介绍),自然也可以使用在stl的容器中。另外它还是线程安全的,这点在多线程程序中也非常重要。
boost::shared_ptr的使用规则:
boost::shared_ptr并不是绝对安全,下面几条规则能使我们更加安全的使用boost::shared_ptr:
-
避免对shared_ptr所管理的对象的直接内存管理操作,以免造成该对象的重释放
-
shared_ptr并不能对循环引用的对象内存自动管理(这点是其它各种引用计数管理内存方式的通病)。
-
不要构造一个临时的shared_ptr作为函数的参数。
如下列代码则可能导致内存泄漏:
void test()
{
foo(boost::shared_ptr<implementation>(new implementation()),g());
}
正确的用法为 :
void test()
{
boost::shared_ptr<implementation> sp (new implementation());
foo(sp,g());
}
===================================================================================================
shared_ptr的使用心得
关键字: 资源获取即初始化 RAII 智能指针 boost shared_prt 资源泄露 内存泄露.
引言:
几乎所有复杂的程序可能都需要引用计数型智能指针。这种智能指针的最突出特点是当某个资源的引用次数为0时,证明该资源已经没有被使用,需要销毁。这时,智能指针会自动将它指向的资源销毁。
最典型的引用计数型智能指针的实现就是boost里的shared_ptr. 具体用法可以参考<<Beyond the C++ Standard Library: An Introduction to Boost>> shared_ptr一小节 或者参考网址:
http://hi.baidu.com/_%E2d_%B7%B3_%DE%B2%C2%D2/blog/item/7cc657339d5d23fc1a4cffa0.html
1.1
现在考虑如下一个资源从创建到销毁的过程:
{
int* pInt = new int(14);
...... // 此处有一系列代码
delete pInt;
}
如果程序在......这些代码的执行中跳出了异常。这样导致程序不会运行到delete pInt2这里,这时资源泄露了。
如何防止这种情况呢? 由此我们联想到类的构造和和类离开作用域时的自动析构.这就是资源获取即初始化技术。资源获取即初始化(RAII, Resource Acquisition Is Initialization)是指,当你
获得一个资源的时候,不管这个资源是对象、内存、文件句柄或者其它什么,你都要在一个对象的构造函数中获得它, 并且在该对象的析构函数中释放它。实现这种功能的类,我们就说它采用了"资源
获取即初始化(RAII)"的方式。这样的类常常被称为封装类。
下面为一个最简单的RAII:
class CMySingleLock
{
public:
CMySingleLock()
{
InitializeCriticalSection(&m_CritSec);
EnterCriticalSection(&m_CritSec);
}
~CMySingleLock (void)
{
LeaveCriticalSection(&m_CritSec);
DeleteCriticalSection(&m_CritSec);
}
private:
CRITICAL_SECTION m_CritSec;
};
这样就可以这样调用:
{
CMySingleLock mySingleLock;
....处理变量
} // 此处mySingleLock已经离开作用域,自动解锁
很多程序用到了该技术,如mutex, criticalSection. 这样,当你创建资源的时候就立即将它放入封装类对象构造函数(new出来的指针立即放入shared_ptr析造函数里), 当该对象离开作用域时,
对象析构函数会自动销毁资源(shared_ptr对象离开作用域时,会自动销毁指向的资源).
1.2
shared_ptr是典型的资源获取即初始化技术。不过shared_ptr采用了更复杂一点RAII方式,因为它实现了引用 计数。当创建资源的时候将它放入一个shared_ptr, shared_ptr内部记录对这种资源的引用次数为1次。当这个shared_ptr对象离开作用域时,引用次数减1,shared_ptr对象析构 时,检查到引用次数为0了,就销毁资源:
{
boost::shared_ptr<int> pInt(new int(14));
assert(pInt.use_count() == 1); // new int(14)这个指针被引用1次
...... // 此处有一系列代码
} //pInt离开作用域, 所以new int(14)被引用次数为0. 指针被销毁。防止了
此处及以下assert代码都会判断成功。如果......跳出异常。那么pInt也离开了作用域,指针照常还是被销毁,所以智能指针可以有效防止资源泄露。
考虑更多次的引用情况:
{
boost::shared_ptr<int> pInt2;
assert(pInt2.use_count() == 0); // temp2还没有引用指针
{
boost::shared_ptr<int> pInt1(new int(14));
assert(pInt1.use_count() == 1); // new int(14)这个指针被引用1次
pInt2 = pInt1;
assert(pInt1.use_count() == 2); // new int(14)这个指针被引用2次
assert(pInt2.use_count() == 2);
} //pInt1离开作用域, 所以new int(14)被引用次数-1
assert(pInt2.use_count() == 1);
} // pInt2离开作用域,引用次数-1,现在new int(14)被引用0次,所以销毁它
不管资源曾经被多少次引用。当它被引用0次时就会销毁。
1.3
在shard_ptr使用中经常会发现,一个对象会有两次被析构的情况。其实这种是因为那个对象指针被两次当成shard_ptr构造函数里的参数。一定要避免这种现象。考虑如下代码:
{
int* pInt = new int(14);
boost::shared_ptr<int> temp1(pInt);
assert(temp1.use_count() == 1); // 用一个指针初始化temp1,temp1认为pInt只被它拥有。所以这个指针被引用1次
boost::shared_ptr<int> temp2(pInt); // 用一个指针初始化temp2,temp2认为pInt只被它拥有。所以这个指针被引用1次
assert(temp2.use_count() == 1);
} // temp1,temp2都离开作用域,它们都销毁pInt. pInt被销毁了两次!系统终于崩溃了 -_-
正确的做法是将原始指针赋给智能指针后,以后的操作都要针对智能指针了.
{
boost::shared_ptr<int> temp1(new int(14)); // 资源获取即初始化
assert(temp1.use_count() == 1);
boost::shared_ptr<int> temp2(temp1);
assert(temp2.use_count() == 2);
} // temp1,temp2都离开作用域,引用次数变为0,指针被销毁
1.4
如果资源的创建销毁不是以new,delete的方式创建销毁怎么办?shared_ptr也可以指定删除器:
// FileCloser.h FileCloser删除器
class FileCloser
{
public:
void operator()(FILE *pf)
{
if (pf)
{
fclose(pf);
}
}
};
// 某实现文件
{
boost::shared_ptr<FILE> fp(fopen(pszConfigFile, "r"), FileCloser()); // 指定调用FileCloser函数对象销毁资源
}
1.5
shared_ptr已经被即将到来的标准库技术报告所采纳,将成为tr1中的一员。为了以后更好的移植现有代码到C++新标准中。可以使用一个namespace的一个小技巧,在头文件StdAfx.h中声明(参考
Effective C++ Item 54):
namespace std
{
namespace tr1 = ::boost; // namespace std::tr1 is an alias
} // for namespace boost
这样就可以用如下方法写代码:
std::tr1::shared_ptr<int> pInt(new int(14));
1.6 完结
bla bla bla......
====================================================================================================