C++经验（六）-- 以对象的形式管理资源

所谓资源，就是程序在运行过程中从系统中借用的东西，一旦用了，当你不用的时候，就必须得还回去。C++最常见的资源就是动态内存分配，也就是我们以new或者malloc等从系统中动态分配的内存，当然资源还包括其他，比如文件描述符、socket、互斥锁、数据库连接等。

那么，为什么要以对象的形式管理资源呢？以对象管理资源，是我们为了对抗资源泄漏而挖的一道战壕。
主要是因为:

• 以对象管理资源的概念常被称为：“资源取得时机便是初始化时机”。(Resource Acquisition Is Initialization; RAII);
• 能依赖C++析构函数的自动调用的机制确保资源被回收。

还记得我们在讲工厂模式的例子，肯德基做鸡腿。我们有个鸡腿类（各种口味），其他各种口味的鸡腿都继承自该类。有一个工厂函数，使得我们能够方便的创建特定口味的鸡腿。

class Chicken 
{
public:
    virtual void show() = 0;
}

class ChickenA  public Chicken 
{
public:
    void show(){std::cout << "this chickenA..."; }
}

...

Chicken* createChicken();

上面的类中，一旦我们调用了createChicken成功返回了函数对象之后，那么我们就有责任对他进行删除。

假设：

{
    auto pChicken = createChicken();
    ...
    delete pChicken;
}

上面的调用看似非常妥当，但是谁能保证 ...的操作部分没有提前return或者其他的一些操作使得控制流并没有按照我们预想地进行。

不要反驳说你说的这种情况是不会存在的。你知道的，当代码进行维护的时候，你就不能保证任何东西，特别是当别人在维护时。

如果控制流从此再也不会执行 delete pChicken; 那么很不好意思的告诉你，内存泄露了。

C++智能指针方便的为我们提供了解决方案。

std::auto_ptr<Chicken> pChicken(createChicken());

如此，当对象离开作用域之后，其析构函数会被自动调用。我们也就不用操心资源泄漏问题了。但auto_ptr管理的资源存在一个问题，就是绝对没有一个以上的auto_ptr指针指向管理的对象。

std::auto_ptr<A> pA1(A());

//std::auto_ptr<A> pA2 = pA;
std::auto_ptr<A> pA2(pA1);    //此时 pA2指向对象，pA1被设为null

C++11之后，引用计数型的智能指针 shared_ptr 能够满足我们更多的需求，比如 auto_ptr 不能被复制。而多个shared_ptr对象可以同时托管一个指针对象。

shared_ptr<Chicken> pChicken(createChicken());

需要注意的是，单个指针的析构和数组的析构问题。因为shared_ptr 和 auto_ptr并不能用作析构数组。

简单的，很多时候我们都需要实现自己的资源管理类。这种情况下要注意他们的copy行为，因为可能他们的copy行为并不能给我们很好的目标和作用。

一般来说，这种情况下，我们都会禁止其默认的copy行为，并且改用引用计数的方法来实现。需要注意的是，假设我们在底层用了shared_ptr，则要注意某些析构的时候并不需要删除的情况。

就算我们有了资源管理类这个堡垒，还是不可避免的在某些情况会访问原始资源，所以每一个RAII对象应该提供一个取得其所管理的资源的办法，一半情况下有两种方式，显示的转换和隐式转换。

int daysMaked(const Chicken* pi);

int dat = daysMaked(pChicken);

上面的调用方式是编译不通过的，因为函数daysMaked需要的是Chicken*指针，而我们送进去的却是shared_ptr<Chicken> 的对象。

通常情况下，有两种方式可以达到目标，就是我们上面说的显示转换和隐式转换。

int dat = daysMaked(pChicken.get());

后面我们会详细的说一下显示转换和隐式转换应该在我们自己写的RAII类中怎么实现。

几乎和所有的指针一样，shared_ptr 和 auto_ptr 也重载了指针取值和操作符（operator* 和 operator->），他们允许指针能够隐式地转换为底部指针。

shared_ptr<Chicken> pChicken(createChicken());
pChicken->show();
(*pChicken).show();

我们看一下下面的这个例子。下面首先提供了两个CAPI。

FontHandle getFont();
void releaseFont(FontHandle fn);

然后有一个资源管理类Font。

class Font
{
public:
    explicit Font(FontHandle f) : m_f(f){}  
    ~Font() {releaseFont(m_f); };
private:
    FontHandle m_f;   //实际的底层字体资源
}

按照正常理解，到此我们就已经基本完成了资源管理类的编写。但是当有大量的需求需要处理FontHandle对象时，我们按照上面的写法就会有很频繁的将Font 对象转换为 FonrHandle对象的需求。比如下面的调用：

void changeFontWeight(FontHandle f, int weight);
void changeFontSize(FontHandle f, int size);
...

此时，在资源管理类中提供一个显示的转换方法是我们能想到的，也是最普遍的一种做法。

class Font
{
public:
    ...
    FontHandle& get(){ return m_f; }
private:
    FontHandle m_f; 
}

这样我们进行底层资源的操作就会变得简单。

void changeFontWeight(FontHandle f, int weight);

Font f(getFont());
int weight = 20;
...
changeFontWeight(f.get(), weight);

有没有发现，当我们在资源类中提供显示的转换方法get后，在需要大量的将Font 对象转换为 FonrHandle对象的需求来说，提供了不可忽略的便利。唯一不爽的是，每次调用的时候都要调用get方法。于是，就有了隐式转换的方法。

class Font
{
public:
    ...
    operator FontHandle() const { return m_f; }
private:
    FontHandle m_f; 
}

下面的例子就是进行了隐式的转换，这样做确实方便了很多。

void changeFontSize(FontHandle f, int size);

Font f(getFont());
int size= 20;
...
changeFontSize(f, size);

但不可避免的，隐式转换存在一个不被人经常注意的隐患。

Font f1(getFont());
FontHandle f2 = f1;

就这样，本来是想对Font对象f1，进行赋值，隐式转换却让我们复制了一个 Fonthandle 对象。如果当f1被销毁，底部字体资源FontHandlle被释放，则对象 f2 就会被虚吊。

• 当要求访问原始资源时，RAII资源管理类应当提供一个能 访问其所管理的资源对象的方法；
• 对原始资源的访问可经由显示转换或者隐式转换获得，一半而言，显示转换比较安全，但隐式转换对调用者来说，是比较方便的。

上面字体资源的测试用例如下：

#include<iostream>

class FontHandle
{
public:
	FontHandle(int a, int b) : m_size(a),m_weight(b) {}
	
	void changeWeight(int w) { m_weight = w; }
	void changeSize(int s) { m_size = s; }
	
	int weight() { return m_weight; }
	int size() { return m_size; }
	
private:
	int m_size{ 0 };
	int m_weight{ 0 };
};

class Font
{
public:
	Font(FontHandle f) : m_f(f) { }
	FontHandle& get() { return m_f; }	
	operator FontHandle() const { return m_f; }
	
private:
	FontHandle m_f;
};

void changeFontWeight(FontHandle& f, int weight)
{
	f.changeWeight(weight);
}

void changeFontSize(FontHandle f, int weight)
{
	f.changeSize(weight);
}

FontHandle getFont()
{
	FontHandle f(3, 10);
	return f;
}

int main()
{
	Font f(getFont());
	
	int weight = 20;
	changeFontWeight(f.get(), weight);	//显示转换 
	std::cout << f.get().weight() << std::endl;
	
	changeFontSize(f, 40);	//隐示转换
	std::cout << f.get().weight() << std::endl;
	
	//对象虚吊 
	FontHandle f2 = f;
	delete &f;
	
	std::cout << f2.weight() << std::endl; //运行异常
	
	return 0;
}