effective c++ 笔记 (13-17)

//---------------------------15/03/30----------------------------

//#13   以对象管理资源

{

void f()

{

Investment *pInv = createInvestment();

...

delete pInv;

}

/*

1:这里很容易出现内存泄漏:

1>...中过早地return。

2>...中抛出异常。

2:为了确保pInv总是被释放，我们需要将资源放进对象内，当控制流离开f时，

这个对象会自动调用析构函数释放掉资源。

3:这里有两个常用的智能指针可以实现：

1>std::auto_ptr。使用方法：std::auto_ptr<Investment> pInv(createInvestment());

记得不要让多个auto_ptr同时指向一个对象，这样会造成多次delete。为了预防这个问题，auto_ptr

在被copy给别的指针时，会变成null。

2>tr1::shared_ptr。这个智能指针使用引用计数，在被copy一次后会自动计数加1，调用一次析构函数

会自动计数减1，当计数为0时销毁对象。

唯一的问题是循环引用。两个没有被使用的对象相互指着对方，这样看起来好像都在使用中，然而并不是这样。

4:如果要对申请到的数组资源使用智能指针，可以使用boost::scoped_array和boost::shared_array

这两个在析构时调用delete[];

*/

}

//#14 在资源管理类中小心coping行为

{

//  auto_ptr和tr1::shared_ptr不适合掌管非heap-based资源。这时候需要自己建立资源管理类

class Lock

{

public:

explicit Lock(Mutex* pm): mutexPtr(pm)

{

lock(mutexPtr);

}

~Lock()

{

unlock(mutexPtr);

}

private:

Mutex *mutexPtr;

};

/*  这时会出现一个问题：如果对象被复制，这个锁会被再锁上一次。如果是在同一线程中这么做

程序就死锁了，无法再恢复。所以大多数时候，可以选择以下两种处理。

1>禁止复制。像Lock这样的class，这样处理是科学的。可以从Uncopyable那用私有继承。

2>对底层资源使用“引用计数法”。Mutex的“引用计数”版本可以使用tr1::shared_ptr，并

指定“删除器”，当引用次数为0时，“删除器”会被调用。代码看起来像这样： 
              */

class Lock

{

public:

explicit Lock(Mutex* pm):mutexPtr(pm, unlock)

{

Lock(mutexPtr.get());

}

private:

std::tr1::shared_ptr<Mutex> mutexPtr;

};

/*  有时候会有两种特殊的需求：

1>复制底部资源(深拷贝)。这是为了当你不需要某个复件时确保它被释放，所以拷贝时要连同

指针指向的资源一起拷贝，不然原始对象删除后就没法用了。

2>转移底部资源的拥有权。就像auto_ptr一样。

*/

}

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

{

/*  1:在资源管理类中，常常需要提供对原始资源的访问，原因是：一些api需要的就是原始资源

如果传入一个资源管理类，它们并不起作用。

2:提供对原始资源访问的方法有二：

1>提供显示访问:                                                   */

class Font

{

public:

explicit Font(FontHandle fh): f(fh)

{}

~Font() { releaseFont(f);}

FontHandle get()const {return f;}

private:

FontHandle f;

};

/*      这样一来就可以通过调用get()来访问原始资源了，但是每次都要用f.get()，显得十分麻烦。

2>提供隐式转换函数：

operator FontHandle() const {return f;}

但是这么做，存在风险，客户有时候笔误就会造成获得一个错误的类型：                */

Font f1(getFont());

...

FontHandle f2 = f1;//本来客户是想要 Font f2 = f1;

/*      但是就算这么调用了，客户也看不出来，因为隐式转换的关系，表达式是可以编译通过的。

而且使用起来也是一样的。最后，当f1被销毁时，问题来了，f2就成为“虚吊的”，就是指向

的资源以及被释放。

3:两种设计各有优势，为了安全倾向显示转换，为了方便倾向隐式转换。

4:RAII class返回原始资源与封装发生矛盾，这是真的。但是并没有关系，RAIIclass是为了确保

资源一定会被释放，而不是为了封装。

*/

}

//#16  成对使用new和delete时要采用相同形式

{

/*  1:当使用new时，有两件事情发生：

1>内存被分配出来。

2>针对此内存会调用构造函数(一个或多个)。

2:当使用delete时，也有两件事发生：

1>先调用析构函数(一个或多个)

2>释放内存。

3:数组对象的内存中一般还包含一个数组大小的记录，以便delete知道需要调用多少次析构函数

所以在调用时必须成对出现，不然会发生不可预测的情况。

4:使用typedef时，最好不要对数组进行typedef。

比如： typedef std::string AddressLines[4];

这样很容易错误地使用delete，所以应该避免这种定义。                            */

}

//#17   以独立的语句将newed对象置入智能指针

{

//  看一个函数调用：

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

/*  这样调用有可能造成内存泄漏，首先，编译器为了效率问题执行以下顺序：

1>new widget;

2>priority();

3>tr1::shared_ptr的构造函数

如果priority()的调用导致异常，那么new Widget返回的指针就遗失了，内存就泄漏了。

所以为了避免着问题很简单：                                               */

std::tr1::shared_ptr<Widget> pw(new Widget);

processWidget(pw, priority());

//  把newed对象置入智能指针的操作用独立语句来实现，这样就不会产生内存泄漏了。

}