Effective c++ 第三章 (资源管理)

条款13:以对象管理资源

假设一个类层次,基类是Investment,然后通过一个工厂函数产生某个特定的invertment对象(可能是某个继承类对象),如下:

//基类
class Investment
{...}

//程序库通过一个工厂函数产生某个特定的inverstment对象,返回指针
Investment* createInvestment(); 

//这导致调用者需要对这个返回的指针进行删除
void f()
{
	Investment* pInv = createInvestment();
	//这里中间可能过早返回,或抛出异常,则都不会执行delete,也就会发生资源泄漏
	...
	delete pInv;
}

      为了解决上述问题,可以使用对象来管理这个对象,当退出f时,自动调用对象的析构函数。

       C++有两个类可以提供:str::auto_ptr, TR1的tr1::shared_ptr。这两个都可以当ptr被销毁时,对象被销毁。为了防止资源泄漏,应使用RAII对象,它们在构造函数汇总获得资源并在析够函数中释放资源。

       注意不能让多个auto_ptr指向同一对象,否则一个对象会被删除多次,严重错误。所以auto为了防止这个问题,有以下不同寻常的性质:若通过copy构造函数或拷贝赋值操作符复制它们,它们会变成null, 而复制所得的指针将取得资源的唯一所有权。由于它的异常拷贝行为,所以它并不是管理动态分配资源的利器。而且不能在STL容器中使用auto_ptr,因为STL容器要求其元素发挥“正常的复制行为”。auto_ptr的行为:     

//解决方法1:使用auto_ptr管理对象资源
void f()
{
	//这里是RAII,获得资源后立刻放进管理对象
    std::auto_ptr<Investment> pInv(createInvestment);

	//auto_ptr的复制行为
	std::auto_ptr<Investment> pInv2(pInv);  //pInv2指向对象,pInv=null
	pInv = pInv2;       //pInv指向对象,pInv2=null

}//离开函数的时候,调用auto_ptr的析构函数确保资源被释放
        auto_ptr的替代方案是“引用计数型智能指针”,它维护一个变量表示共有多少对象指向某笔资源,并在变量变为0时删除对象。类似垃圾回首,但无法打破环状引用。它的拷贝行为正常:
//解决方法2:使用tr1::shared_ptr管理对象资源
void f()
{
	//这里是RAII,获得资源后立刻放进管理对象
    std::tr1::shared_ptr<Investment> pInv(createInvestment);

	//shared_ptr的复制行为
	std::tr1::shared_ptr<Investment> pInv2(pInv);  //pInv2, pInv指向同一对象
	pInv = pInv2;       //pInv,pInv2指向同一对象

}//离开函数的时候,调用shared_ptr的析构函数确保pInv,pInv2被释放
         令auto_ptr与shared_ptr都在其析构函数内做delete而不是delete[],这意味着在动态分配而得的array上使用它们是不应该的,如:

//以下行为虽然可以通过编译器,但是会有资源泄漏,不应该使用
std::auto_ptr<std::string> aps(new std::string[10]);
std::tr1::shared_ptr<std::string> api(new int[1024]);

条款14:在资源管理类中小心copying行为

        对于某些资源,并不适合使用auto_ptr和shared_ptr管理资源,有可能需要自己写管理资源的类,并遵守RAII,例如以下,Mutex表示互斥对象,lock, unlock对资源管理,可以建一个类来管理这个资源,并且对于这个类的拷贝行为,可以有以下四种行为,如下:

//资源管理类的copying行为

class Lock
{
public:
	explicit Lock(Mutex* pm) : mutexPtr(pm)
	{
		lock(mutexPtr); //构造函数锁住资源
	}

	~Lock()
	{
		unlock(mutexPtr);  //析构函数释放资源
	}
};

//客户端的用法
Mutex m;
Lock ml(&m);  //锁定,执行关键区域内的操作
...

//如果进行拷贝,可以发生以下情况:
Lock ml1(&m);
Lock ml2(ml1);

//情况1:禁止复制,参考条款6的做法,
//1声明为私有,不定义,如果复制发生链接错误
//2建一个不能拷贝的基类,并私有继承于它,这将错误移到编译期
class Lock : private Uncopyable
{
};

//情况2:引用计数法,例如shared_ptr的行为,但当资源变为0时,它的默认行为是
//删除所指物,而如果我们只是释放锁定,这种情况下可以利用shared_ptr中可以指定“删除器”
//的一个函数或函数对象,当引用计数为0时,调用此函数,这个参数对它的构造函数是可有可无的第二个参数
class Lock
{
public:
	explicit Lock(Mutex* pm) : mutexPtr(pm, unlock) //unlock即为指定的删除器
	{
		lock(mutexPtr.get());
	}
private:
	std::tr1::shared_ptr<Mutex> mutexPtr; //用shared_ptr管理这个对象,并且指定删除器,自定义行为
};
//而且以上不再需要析够函数,因为析构函数会在引用计数为0时自动调用shared_ptr的删除器

//情况3:复制底部资源,进行深度拷贝,例如string类,

//情况4:转移底部所有权,如auto_ptr的行为,资源所有权从被复制物转移到目标物

      总结:1 赋值RAII对象必须一并复制它所管理的资源,所以资源的copying行为决定RAII对象的拷贝行为 2 普遍而常见的RAII类拷贝行为是:抑制拷贝,施行引用 计数法。不过其他行为也都可能实现。


        条款15:在资源管理类中提供对原始资源的访问

       APIs往往要求访问原始资源,所以每个RAII类应该提供一个“取得其所管理之资源”的方法。

       对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全,但隐式转换对客户比较方便。例如shared_ptr与auto_ptr都提供了一个get函数,来返回指向的内部资源。再如下面的例子:

//资源管理类中提供对原始资源的访问

class Font
{
public:
	explicit Font(FontHandle fh) : f(fh)
	{}

	//可以提供两种访问原始资源的方式:
	//1 显示转换函数,优点是安全,缺点是每次调用都需要访问该函数
	FontHandle get() const
	{
		return f;
	}

	//2 隐式转换,重载转换操作符,优点不需显示调用,会隐式执行,缺点:容易出错
	operator FontHandle() const
	{
		return f;
	}

	~Font()
	{
		releaseFont(f);
	}
private:
	FontHandle f;  //管理的原始字体资源
};
        对于隐式的转换会增加错误发生的机会,如下:

Font f1(getFont());
FontHandle f2 = f1;  //本来是想拷贝Font对象,却隐式转换f1为FontHandle,然后进行了复制

      以上一个潜在的问题是,f1拥有的资源被f2取得,这不会有好下场,例如f1被销毁,字体释放,f2成为虚吊的。

       所以获得RAII底部资源,是使用显示调用还是隐式转换,取决于RAII类被设计的特定工作,以及它被使用的情况。条款18有,让接口容易被正确使用,不易被勿用,所以显示的get通常比较受欢迎。

 

       条款16:成对的使用new和delete时采取相同的形式

       如果在new表达式中使用[ ], 必须在相应的delete表示式中也使用 [ ], 如果new不使用,delete也不要使用。

       这其实就是数组与单个对象的形式。因为单一对象的内存布局一般而言不同于数组内存布局。数组内存通常还包括“数组大小”,以便知道delete需要调用多少次析构函数。单一对象没有这笔记录。

       当使用new时,有两件事发生:1 内存会被分配出来(通过operator new) 2针对此内存调用一个(或多个)构造函数;

       当使用delete时,有两件事发生:1 析构函数调用  2 内存被释放(通过operator delete)

       当你写的一个类中含有一个指针指向动态分配的内存,并提供多个构造函数时,这时要使所有构造函数中使用相同的形式的new将指针成员初始化,因为析构函数中只能有一种delete形式。

       最好不要对数组形式做typedefs动作,不然容易发生错误:   

typedef std::string AddressLines[4];  //定义了一个AddressLines类型,执行string [4]

std::string* pal = new AddressLines; //这里分配的是数组,相当于new string[4]

delete pal;  //错误,但是可能会发生
delete [] pal; //正确的形式,但与以上new不对称

       条款17:以独立语句将newed对象置如智能对象。

       如以下例子会有隐式的资源泄漏:

//以独立语句将newed对象置入智能指针
//有以下函数
int priority();
void processWidget(std::tr1::shared_ptr<Widget> pw, int priority);

//以下调用形式,不会通过编译,因为tr1::shared_ptr的构造函数是explicit函数
//虽然它接受一个widget的指针,但是不能进行隐式转换,
processWidget(new Widget, priority());

//所以如果使用以下强制转化,可以通过,但这可能有隐式的资源泄漏
processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());

       对于std::tr1::shared_ptr<Widget>(new Widget)的调用有两部分组成:

      1 执行“new Widget”表达式

      2 调用tr1::shared_ptr构造函数

      于是在调用processWidget之前,必须做以下三件事:

      * 调用priority

      * 执行“new Widget”表达式

      * 调用tr1::shared_ptr构造函数

       但编译器完成以上事情的次序并不一定,但是new Widget一定在shared_ptr构造函数之前,它有可能是以下序列

      1 执行“new Widget”表达式

      2调用priority

      3调用tr1::shared_ptr构造函数

      这样可能会有资源泄漏,即如果priority调用过程中发生异常,则new出的指针会丢失!!太隐蔽了。。。

      为了避免以上事情的发生:使用分离语句  1 创建Widge,构造一个智能指针,2 传给processWidget   

//解决方案:
std::tr1::shared_ptr<Widget> pw(new Widget);
processWidget(pw, priority());

        总结:以独立语句将newed对象存储与智能指针内,如果不这么做,一旦异常被抛出,可能导致难以察觉的资源泄漏。


你可能感兴趣的:(Effective c++ 第三章 (资源管理))