今天來講講怎么編寫異常安全的代碼。
程序運行過程中，往往需要對一些流程加入異常處理，來提高程序的robust.比如
通過try catch來捕捉異常
try
{
??? pMemory = new char[MAX_BUF_SIZE];
}
catch(std::bad_alloc& e)
{
??? //error handling,er:do something resource free
}
但在程序代碼段中出現(xiàn)大量的try catch,不僅從美觀，效率和程序輸寫上都是不怎么好。
而另外一種對于異常的處理方法是依賴于c++的ctor/dctor的匹配來做的，就是所謂的
RAII,這個很容易讓人聯(lián)想到std::auto_ptr
std::auto_ptr<int> tmp(new int);
通過new分配的對象會在tmp生命結(jié)束后，釋放相關(guān)的資源，通過這種方式，就能保證在程序異常，或退出時，已分配的對象能正確自動的釋放擁有的資源，而在對象聲明周期內(nèi)，可以保證資源的有效性。
這種方式就是今天blog要寫的主要內(nèi)容，我們可以看到std::auto_ptr作用范圍很小，只能對從堆上分配的對象進(jìn)行管理，假如對文件打開句柄實行RAII,你也許會認(rèn)為再寫個不就是了，但這樣只會造成源代碼里充滿了這些資源管理的類，這導(dǎo)致了一個嚴(yán)重的問題，好的結(jié)構(gòu)在繁瑣的流暢前面變的難堪。
那怎么樣對這個進(jìn)行泛化，從而能對比如從簡單的指針釋放，文件句柄維護(hù)，甚至相關(guān)的成員函數(shù)。我們來看下loki::socpeguard是怎么實現(xiàn)的：
先看下基本的用法
(1)? FILE* hFileOpen = fopen(....);
(2)? LOKI_ON_BLOCK_EXIT(flose,hFileOpen);
line2會在出LOKI_ON_BLOCK_EXIT域或程序異常結(jié)束時被調(diào)用，下面是對類成員的調(diào)用
void CTestObject::Create
{
??? LOKI_ON_BLOCK_EXIT_OBJ(*this,FressResouce);
??? ...
}
同上面差不多，會在這個函數(shù)結(jié)束后或異常結(jié)束后調(diào)用類成員的FreeResource.在正常流程結(jié)束后，可以通過調(diào)用Dismiss來防止對FreeResouce的調(diào)用，即類似數(shù)據(jù)庫操作的commit操作。下面來分析下LOKI的實現(xiàn)：
從上面可以看到，RAII的是：
1：構(gòu)造函數(shù)對資源的獲取
2：稀構(gòu)函數(shù)對資源的釋放
先來看下LoKi對上面那2個宏的定義
#define LOKI_ON_BLOCK_EXIT????? Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = Loki::MakeGuard
#define LOKI_ON_BLOCK_EXIT_OBJ? Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = Loki::MakeObjGuard
上面的Loki::ScopeGuard是一個基類的別名
typedef const ScopeGuardImplBase& ScopeGuard;
而LOKI_ANONYMOUS_VARIABLE(scopeGuard)用來我們產(chǎn)生唯一的名字，有時假如需要調(diào)用Dismiss的話，則需要自己去實現(xiàn)宏定義的內(nèi)容，這樣才能通過對象訪問。Loki::MakeGuard或Loki::MakeObjGuard是用來產(chǎn)生對象的實際類型的，下面是一個
Loki::MakeGuard的例子：
template <typename F, typename P1>
inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
{
??? return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
}
可以看到ScopeGuardImpl1<F, P1>是要產(chǎn)生的具體類型，MakeGuard通過函數(shù)參數(shù)的數(shù)目來重載的，而MakeGuard此處的作用是要睡死了...-_-'',作用是利用函數(shù)自動推導(dǎo)出參數(shù)的類型，這樣就免去了指定ScopeGuardImpl1的類型的麻煩，而
ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
簡單的返回對象的一個臨時變量，并assign給一個上面的一個scopeguard的實例，這里依賴一個C++的特性，臨時變量的聲命周期和通過他初始化的引用類型的聲明周期是一致的。
從上面可以看到Loki定義了一個ScopeGuardImplBase的基礎(chǔ)類。這個類定義了一個基本的方法Dismiss,以及相關(guān)的狀態(tài)。下面是loki中這個類的定義
class ScopeGuardImplBase
{
??? ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
?protected:
??? ~ScopeGuardImplBase()
??? {}
??? ScopeGuardImplBase(const ScopeGuardImplBase& other) throw()
??????? : dismissed_(other.dismissed_)
??? {
??????? other.Dismiss();
??? }
??? template <typename J>
??? static void SafeExecute(J& j) throw()
??? {
??????? if (!j.dismissed_)
?????????? try
?????????? {
????????????? j.Execute();
?????????? }
?????????? catch(...)
?????????? {}
???? }
???????
???? mutable bool dismissed_;
public:
???? ScopeGuardImplBase() throw() : dismissed_(false)
???? {}
???? void Dismiss() const throw()
???? {
???????? dismissed_ = true;
????? }
};
可以看到類里面定義了上面所說的一些屬性，其中SafeExecute用來提供子類同一的資源釋放方法，并調(diào)用子類的方法來具體操作，因為相關(guān)的函數(shù)，變量都保存在具體的子類，可以看到這個函數(shù)使用了try catch，這里加這個的目的是，因為資源釋放要在子類的稀構(gòu)里被觸發(fā)，而調(diào)用具體的方法是外面?zhèn)鬟M(jìn)來的，所以無法保證一定是異常安全的，而假如在稀構(gòu)里面異常的話，會導(dǎo)致程序的行為無法定義。
下面具體來看下一個子類的實現(xiàn)：
template <typename F, typename P1>
class ScopeGuardImpl1 : public ScopeGuardImplBase
{
public:
??? static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
??? {
??????? return ScopeGuardImpl1<F, P1>(fun, p1);
??? }
??? ~ScopeGuardImpl1() throw()
??? {
??????? SafeExecute(*this);
??? }
??? void Execute()
??? {
??????? fun_(p1_);
??? }
protected:
??? ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1)
??? {}
??? F fun_;
??? const P1 p1_;
};
在LoKi里面可以看到很多類似ScopeGuardImpl1的定義，比如ScopeGuardImpl0，
ScopeGuardImpl2，可以發(fā)現(xiàn)最后面的數(shù)字表示具體參數(shù)的數(shù)目。
可以看到上面所說的MakeGuard的定義，以及對基類方法的調(diào)用，可以看到構(gòu)造函數(shù)接收的類型，一個函數(shù)對象，和一些參數(shù)對象，并保存，對于成員函數(shù)的scopeguard,LoKi定義了1些相似的類，主要是增加了對象的引用，還有就是函數(shù)的調(diào)用方式上。
上面可以看到參數(shù)是通過值的方式來保存的而不是通過引用。而且是const屬性的，下面是相關(guān)的分析。
1：通過傳值的方式，從而避免了異常拋出時，可能引用的對象被稀構(gòu)
2：加const屬性，從而保證了在func需要參數(shù)是reference時而保存的參數(shù)確是非const時產(chǎn)生相應(yīng)的編譯錯誤，因為對reference傳人const non-reference形式是錯誤的。
而對于1的方式，存在的一種問題是假如操作的fun需要傳入引用，那傳進(jìn)去的值就無法在釋放的函數(shù)中被改變，而2是對這種的一種類似契約似的編程，Loki 提供的方法是通過一個中間對象來保存操作參數(shù)的引用，并賦予這個對象自動轉(zhuǎn)換功能。下面是這個類的定義：
template <class T>
class RefToValue
{??
public:
??? RefToValue(T& ref) : ref_(ref)
??? {}
??? RefToValue(const RefToValue& rhs) : ref_(rhs.ref_)
??? {}
??? operator T& () const
??? {
??????? return ref_;
??? }
private:
??? // Disable - not implemented
??? RefToValue();
??? RefToValue& operator=(const RefToValue&);
???????
??? T& ref_;
};
可以很清楚的看到類的實現(xiàn)，下面是一個工具類
template <class T>
inline RefToValue<T> ByRef(T& t)
{
???? return RefToValue<T>(t);
}
下面給個具體的例子，假如
template<typename _Ty>
void SAFEDELETE(_Ty*& ptr)
{
?? if (NULL != ptr)
????? delete ptr;
?? ptr = NULL;
}
char* ptr = new char;
?
{
??? LOKI_ON_BLOCK_EXIT(SAFEDELETE<char>,Loki::ByRef(ptr));
}
?
if (NULL == ptr)
? std::cout << "NULL" << std::endl;
基本上就這么多了，sleep去了
??????????????????????????????????????????????????? alex_yuu