Effective C++ 读书笔记（三）
3 资源管理
条款13：以对象管理资源
基于对象的资源管理方法，建立在C++对构造函数、析构函数、copying函数的基础之上，依赖c++的“析构函数自动调用机制”确保资源被释放。
auto_ptr和 shared_ptr一个简单的基本实现，只反应其基本原理。
|
template<typename _Tp> class auto_ptr { private: _Tp* _M_ptr;
public: typedef _Tp element_type; explicit auto_ptr( element_type* __p = 0) :_M_ptr(__p) { }
template<typename _Tp1> auto_ptr( auto_ptr <_Tp1> & __a) : _M_ptr ( __a.release() ) { }
//注意，赋值的时候，同时会把原来的auto_ptr变量中的指针设置为NULL auto_ptr& operator=(auto_ptr& __a) { reset(__a.release()); return *this; } template<typename _Tp1> auto_ptr& operator=(auto_ptr<_Tp1>& __a) { reset(__a.release()); return *this; } // 重载* 和-> 让auto_ptr看起来更像是个指针。 element_type& operator*() const { _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); return *_M_ptr; } element_type*operator->() const { _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); return _M_ptr; } //注意他的实现 element_type*release() { element_type* __tmp = _M_ptr; _M_ptr = 0; return __tmp; } void reset(element_type* __p = 0) { if (__p != _M_ptr) { delete _M_ptr; _M_ptr = __p; } } }; |
template<class T> class shared_ptr { public: typedef unsigned long size_type; private: void dispose() { if (--*pn == 0) { delete px; delete pn; } }
T* px; // contained pointer size_type* pn; // reference counter
public: explicit shared_ptr(T* p=0): px(p) { pn = new size_type(1) }
shared_ptr& operator= (T* p) { if(this->px == p) return *this;
dispose(); pn = new size_type(1); px=p; return *this; }
shared_ptr(const shared_ptr& r) throw(): px(r.px) { ++*r.pn; pn = r.pn; }
shared_ptr& operator= (const shared_ptr& r) throw() { if(this == &r) return *this; dispose(); px = r.px; ++*r.pn; pn = r.pn; return *this; } } |
std::auto_ptr<Investment> pInv1(createInvestment());
std::auto_ptr<Investment> pInv2(pInv1); //Now, pInv2指向对象，pInv1设为null
pInv1 = pInv2; //Now, pInv1指向对象，pInv2设为null
std::tr1::shared_ptr<Investment> pInv1(createInvestment());
std::tr1::shared_ptr<Investment> pInv2(pInv1); //Now, pInv2, pInv1指向同一个对象
pInv1 = pInv2; //同上，无任何改变
条款14：在资源管理类中小心copying行为
假设有如下两个函数：
void lock( Mutex* pm); //锁定pm所指的互斥器
void unlock(Mutex* pm);//将互斥器解除锁定
建立一个class来管理锁：
class Lock{
public:
explicit Lock(Mutex* pm): mutexPtr(pm) { lock(mutexPtr); }
~Lock() { unlock(mutexPtr); }
private:
Mutex* mutexPtr;
};
应用：
Mutex m;
{
Lock m1(&m)
…
}//自动解锁
但如果Lock对象被复制，会发生什么？？
Lock m1(&m);
Lock m2(m1);
解决方案有：1， 禁止复制。 2，对底层资源祭出引用计数法，保有资源只到它的最后一个使用被销毁。
如：
class Lock{
public:
explicit Lock(Mutex* pm): mutexPtr(pm, unlock) { lock(mutexPtr.get()); }
//以某个Mutex初始化shared_ptr，并以unlock函数为删除器
private:
std::tr1::shared_ptr<Mutex> mutexPtr;
};
class的析构函数会自动调用non-static成员变量的析构函数。mutexPtr的析构函数会在互斥器的引用计数为0时调用删除器（本例为unlock）。
条款15：在资源管理类中提供对原始资源的访问
条款13中使用auto_ptr或tr1::shared_ptr保存factory函数如createInvestment的调用结果：std::tr1::shared_ptr<Investment> pInv( createInvestment() );
假设你想以函数处理Investment对象，int daysHeld(const Investment* pi);
有两个办法，显式转换和隐式转换。
n 显式转换
shared_ptr和auto_ptr提供get函数，返回智能指针内部的原始指针。
即int days = daysHeld(pInv.get());
类似地：
FontHandle getFont();
void releaseFont(FontHandle fh);
class Font{
public:
explicit Font(FontHandle fh):f(fh){}
~Font(){ releaseFont(f); }
FontHandle get()const {return f;} //提供显式转换函数
private:
FontHandle f;
};
void changeFontSize(FontHandle f, int newSize);
Font f(getFont());
int newFontSize;
changeFontSize(f.get(), newFontSize);
n 隐式转换
class Font{
public:
…
operator FontHandle()const {return f;} //提供隐式转换函数
…
};
Font f(getFont());
int newFontSize;
changeFontSize(f, newFontSize);
条款16:成对使用new和delete时要采用相同形式
如果你在new表达式中使用[ ]，必须在相应的delete表达式中也使用[ ]。如果你在new表达式中没有使用[ ]，一定不要在相应的delete表达式中使用[ ]。
如果你使用delete时加上[ ]，delete便认定指针指向一个数组，否则它认定指针指向一个单一对象。
std::string *str1 = new std::string;
std::string *str2 = new std::string[10];
delete str1;
delete [ ]str2;
最容易犯错的情形是使用typedef的情形：
typedef std::string AddressLines[4];
std::string* pal = new AddressLines; //”new AddressLines”返回一个string*
delete [ ] pal;
条款17：以独立语句将newed对象置入智能指针
int priority();
void processWidget(std::tr1::shared_ptr<Widget> pw, int priority);
调用：processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());
在调用processWidget之前，编译器必须创建代码，做三件事：
n 调用priority();
n 执行new Widget
n 调用shared_ptr的构造函数
执行顺序可能为：
1, new widget
2, 调用priority
3, 调用shared_ptr构造函数
但若在第2步出现异常，将出现内存泄漏。
解决方案：
std::tr1::shared_ptr<Widget> pw(new Widget);
processWidget(pw, priority());
