Effective c++读书笔记三

三.资源管理

  所谓资源就是,一旦用了它,将来必须还给系统。C++程序中最常使用的资源就好似动态分配内存(如果你new了,却忘了delete,会导致内存泄露),但内存只是你必须管理的众多资源之一。其它常见的有文件描述符(file descriptors)、互斥器(mutex)、图形界面中的字形和画刷。数据库连接以及网络sockets。当你不使用它们时,记得还给系统。
  当你考虑到异常、函数内多重回传路径、程序维护员改动软件却没能充分理解随之而来的冲击,那么资源管理就显得复杂的多。

条款13:以对象管理资源

例:
Investment * creatInvestment();//返回指针,指向Investment继承体系内的动态分配对象。调用者有责任删除它。
 void f()
 { 
     Investment *pInv = createInvestment(); 
     ...                   //这里存在诸多“不定因素”,可能造成delete pInv;得不到执行,这可能就存在潜在的内存泄露。
     delete pInv;
 } 

  解决方法:把资源放进对象内,我们便可依赖C++的“析构函数自动调用机制”确保资源被释放。
  许多资源被动态分配于堆内而后被用于单一区块或函数内。它们应该在控制流离开那个区块或函数时被释放。标准程序库提供的auto_ptr正是针对这种形势而设计的特制产品。auto_ptr是个“类指针对象”,也就是所谓的“智能指针”,其析构函数自动对其所指对象调用delete。下面举例说明用auto_ptr以避免f函数潜在的资源泄漏可能性。
void f()
{
std::auto_ptr pInv(createInvestment()); //pInv1指向creatInvestment返回物 Investment是类

} //函数退出,auto_ptr调用析构函数自动调用delete,删除pInv;无需显示调用delete。
“以对象管理资源”的两个关键想法:

获得资源后立刻放进管理对象内(如auto_ptr)。每一笔资源都在获得的同时立刻被放进管理对象中。以资源管理对象的概念常被称作“资源取得时机便是初始化时机”(Resource Acquisition Is Initialization;RAII)。

管理对象运用析构函数确保资源被释放。即一旦对象被销毁,其析构函数被自动调用来释放资源。

  由于auto**_ptr被销毁时会自动删除它所指之物,所以不能让多个auto_ptr**同时指向同一对象。所以auto_ptr若通过copy构造函数或者赋值操作符函数复制它们,它们会变成NULL,而复制所得的指针将取得资源的唯一拥有权!
  看下面例子:
std::auto_ptr pInv1(createInvestment()); //pInv1指向createInvestment()返回物;
std::auto_ptr pInv2(pInv1); //现在pInv2指向对象,而pInv1被设为NULL;
pInv1 = pInv2; //现在pInv1指向对象,而pIn2被设为NULL;
  受auto_ptr管理的资源必须绝对没有一个以上的auto_ptr同时指向它。所以STL容器容不得auto_ptr.
  auto_ptr的替代方案是“引用计数型智能指针”(reference-counting smart pointer;SCSP)、它可以持续跟踪共有多少对象指向某笔资源,并在无人指向它时自动删除该资源。
TR1的tr1::shared_ptr就是一个”引用计数型智能指针”。
void f()
{

std::tr1::shared_ptr pInv1(createInvestment()); //pInv1指向createInvestment()返回物;
std::tr1::shared_ptr pInv2(pInv1); //pInv1,pInv2指向同一个对象;
pInv1 = pInv2; //同上,无变化

} //函数退出,pInv1,pInv2被销毁,它们所指的对象也竟被自动释放。
  auto_ptr和tr1::shared_ptr都在其析构函数内做delete而不是delete[],也就意味着在动态分配而得的数组身上使用auto_ptr或tr1::shared_ptr是个潜在危险,资源得不到释放。也许boost::scoped_array和boost::shared_array能提供帮助。还有,vector和string几乎总是可以取代动态分配而得的数组。
  
请记住:
  为防止资源泄漏,请使用RAII对象,它们在构造函数中获得资源并在析构函数中释放资源。
  两个常被使用的RAII类分别是auto_ptr和tr1::shared_ptr。后者通常是较佳选择,因为其拷贝行为比较直观。若选择auto_ptr,复制动作会使他(被复制物)指向NULL。

条款14:在资源管理类中小心拷贝行为*

  我们在条款13中讨论的资源表现在堆上申请的资源,而有些资源并不适合被auto_ptr和tr1::shared_ptr所管理。可能我们需要建立自己的资源管理类。
例:
void lock(Mutex *pm); //锁定pm所指的互斥量
unlock(Mutex *pm); //将pm解除锁定
我们建立的资源管理类可能会是这样:
class Lock
{
public:
explicit Lock(Mutex *pm)
: mutexPtr(pm)
{
lock(mutexPtr);
}
~Lock()
{
unlock(mutexPtr);
}
private:
Mutex *mutexPtr;
};
但是,如果Lock对象被复制,会发生什么事???
“当一个RAII对象被复制,会发生什么事?”大多数时候你会选择一下两种可能:
禁止复制。如果复制动作对RAII类并不合理,你便应该禁止之。禁止类的copying函数参见条款6。
对底层资源使用”引用计数法“。有时候我们又希望保有资源,直到它的最后一个使用者被销毁。这种情况下复制RAII对象时,应该将资源的”被引用计数“递增。tr1::shared_ptr便是如此。
通常只要内含一个tr1::shared_ptr成员变量,RAII类便可实现”引用计数“行为。
class Lock
{
public:
explicit Lock(Mutex *pm)
: mutexPtr(pm, unlock) //由于tr1::shared_ptr缺省行为是”当引用计数为0时删除其所指物“,幸运的是 //我们可以指定”引用计数“为9时被调用的所谓”删除器“,即第二个参数unlock
{
lock(mutexPtr.get());
}
private:
std::tr1::shared_ptr mutexPtr;
};
   本例中,并没说明析构函数,因为没有必要。编译器为我们生成的析构函数会自动调用其non-static成员变量(mutexPtr)的析构函数。而mutexPtr的析构函数会在互斥量”引用计数“为0时自动调用tr1::shared_ptr的删除器(unlock)。
Copying函有可能被编译器自动创建出来,因此除非编译器所生成版本做了你想要做的事,否则你得自己编写它们。
请记住:
  复制RAII对象必须一并复制它所管理的资源,所以资源的copying行为决定RAII对象的copying行为。
  普遍而常见的RAII类拷贝行为是:抑制拷贝,施行引用计数法。不过其它行为也可能被实现。

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

  资源管理类很棒。它们是你对抗资源泄漏的堡垒。但这个世界并不完美,许多APIs直接指涉资源,这时候我们需要绕过资源管理对象直接访问原始资源。
  这时候需要一个函数可将RAII对象(如tr1::shared_ptr)转换为其所内含之原始资源。有两种做法可以达成目标:显示转换和隐式转换。
tr1::shared_ptr和auto_ptr都提供一个get成员函数,用来执行显示转换,也就是返回智能指针内部的原始指针(的复件)。就像所有智能指针一样, tr1::shared_ptr和auto_ptr也重载了指针取值操作符(operator->和operator*),它们允许隐式转换至底部原始指针。(即在对智能指针对象实施->和*操作时,实际被转换为被封装的资源的指针。)
class Investment{
public :
bool isTaxFree() const;

};
Investment* creatInvestment();
std::tr1::shared_ptrpi1(creatInvestment());
bool taxable1=!(pi1->isTaxFree());

std::tr1::shared_ptrpi2(creatInvestment());
bool taxable2=!((*pi2).isTaxFree());

class Font
{
public:

FontHandle get() const //FontHandle 是资源; 显示转换函数
{
return f;
}
operator FontHandle() const //隐式转换 这个值得注意,可能引起“非故意之类型转换”
{
return f;
}

};
  是否该提供一个显示转换函数(例如get成员函数)将RAII类转换为其底部资源,或是应该提供隐式转换,答案主要取决于RAII类被设计执行的特定工作,以及它被使用的情况。
  显示转换可能是比较受欢迎的路子,但是需要不停的get,get;而隐式转换又可能引起“非故意之类型转换”。
请记住:
  APIs往往要求访问原始资源,所以每一个RAII类应该提供一个“取得其所管理之资源”的方法。
  对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全,但隐式转换对客户比较方便。

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

先看下一下代码:
 std::string *stringArray = new std::string[100];
 ... 
 delete stringArray;

  使用了new动态申请了资源,也调用了delete释放了资源。但这代码存在“不明确行为”。stringArray对象中的99个不太可能被适当删除,因为它们的析构函数很可能没被调用。
  当我们使用new,有两件事情发生:第一,内存被分配出来;第二,针对此内存会有一个(或更多)构造函数被调用。当你使用delete,也有两件事发生:针对此内存会有一个(或多个)析构函数被调用,然后内存才被释放。delete的最大问题在于:即将被删除的内存之内究竟有多少对象?这个问题的答案决定了有多少个析构函数必须被调用起来。
  解决以上问题事实上很简单:如果你调用new时使用[],你必须在对应调用delete时也使用[]。如果你调用new时没有使用[],那么也不该在对应调用delete时使用[]。这个规则对于喜欢使用typedef的人很重要。
  
这里补充typedef相关知识:
在编程中使用typedef目的一般有两个,一个是给变量一个易记且意义明确的新名字,另一个是简化一些比较复杂的类型声明。
(1)
typedef int size;
size array[4];
(2)
typedef char Line[81];//Line类型即代表了具有81个元素的字符数组
Line text;

请记住:
  如果你在new表达式中使用[],必须在相应的delete表达式中也使用[]。如果你在new表达式中不使用[],一定不要在相应的delete表达式中使用[]。

条款17:以独立语句将newed对象置入智能指针

危险情况:

int priority();
void processWidget(std::tr1::shared_ptr<Widget> (new Widget), int priority);

因为std::tr1::shared_ptr pw(new Widget); 可能会泄露资源。这句代码后会有三个执行步骤:
1.执行new Widget
2.调用priority
3.调用tr1::shared_ptr构造函数
步骤2,3顺序不一定。如果步骤2 的调用出现异常,步骤1返回的指针将会遗失,继而引发资源泄漏。所以解决方法:使用独立语句

std::tr1::shared_ptr<Widget> (new Widget);
//在单独语句内以智能指针存储newed所得对象
processWidget(pw, priority()); //这个调用绝对不至于造成泄漏

因为编译器对“跨越语句的各项操作”没有重新排列的自由。

请记住:
  以独立语句将newed对象存储于(置入)智能指针内。如果不这样做,一旦异常抛出,有可能导致难以察觉的资源泄漏。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值