異常c/c++

1.c語言傳統處理錯誤方式

1、終止程序

2、返回錯誤碼

2.c++異常概念

3.異常的使用

?3.1異常的拋出與捕獲

3.2異常安全（還有一些異常重新拋出）

3.3異常規范

4.自定義異常體系

5.c++標準庫的異常體系

6.異常優缺點

?1、優點

2、缺點

7、補充

1.c語言傳統處理錯誤方式

1、終止程序

如assert斷言、內存錯誤（原因有很多，越界訪問啊等等）、除0錯誤

2、返回錯誤碼

錯誤碼，常見的就是程序運行后，如果沒有錯誤的話，就是返回0，不正常的時候返回負的多少或者其他奇怪的數字。很多庫的接口函數都把錯誤碼放到errno中，表示錯誤。遇到這種，錯誤的原因需要查表或者自行尋找到錯誤原因。

2.c++異常概念

?異常在很多面向對象的語言都有，python也有。

異常是一種處理錯誤的方式，可以理解為程度比assert輕一點，處理方式不是粗暴的終止程序。當出現某個編譯器無法處理的錯誤時，可以將其作為異常拋出，由程序員預先設置的程序來處理這個錯誤。

throw：拋出異常，“throw 字符串或數字”

catch:捕獲異常，比如捕獲到了字符串或數字，就會進入對應的塊域中，執行設定的語句。可以多個catch捕獲多個異常（比如針對字符串的、針對數字的）

try:在try里面的語句，都會在運行時進行檢查，如果遇到異常，把異常拋出后，會馬上跳到catch中。
try
{// 保護的標識代碼
}catch( ExceptionName e1 )
{// catch 塊
}catch( ExceptionName e2 )
{// catch 塊
}catch( ExceptionName eN )
{// catch 塊
}
void fa() {int a; cin >> a;if (a == 2){throw "wdawd";}else if (a == 3){throw 4;}else if (a == 4){string s("dwwdawda");throw s;}else if (a == 5){stack<int>s;s.push(2);throw s;}
}int main()
{try {fa();}catch (const char* err){cout << err << endl;}catch (int x){cout << x << endl;}catch (const string& es){cout << es << endl;}catch (...) {cout << 231231 << endl;}return 0;
}
如果沒有遇到異常，在執行完try里面的語句后，會直接跳過catch里面的內容。

注意，如果是庫里的對象返回的話，建議用const 類型&來接受，因為這樣如果這個對象有移動拷貝的話，這個寫法可以接受右值也可以接受左值，提高效率。

3.異常的使用

?3.1異常的拋出與捕獲

相比c語言傳統的錯誤碼（遇到錯誤，要層層返回，每層都要處理，直到返回main函數），異常可以直接跳回到匹配的catch處。這個過程中，跳過的函數都是會正常銷毀的

異常拋出和匹配原則

1、異常是通過拋出對象引出的，該對象的類型決定了應該激活哪個catch

2、被選中的處理代碼是調用鏈（就是從main到第一個函數到其內的函數再到其內的函數，一路下去）中與對象類型匹配且距離拋出異常的位置最近的，比如在第一個函數處也有try，然后執行try里面的內容時拋了異常，并且catch的內容與拋出的對象的類型是匹配的，那就會執行第一個函數處的對應catch而不是main函數處的catch。

3、catch(...)可以捕獲任意類型的異常，問題是不知道異常是什么? ?用來兜底的，建議一定加

4、拋出異常后，對于相應的對象，會生成該對象的拷貝，因為這個對象可能是個臨時對象（比如局部變量），這個拷貝出來的對象，在catch之后會銷毀。（效率還是很高的，因為臨時對象的話，走移動拷貝，效率挺高的）。比如我們拋出了一個string對象，就上面的代碼中一樣。

5、類型不一定嚴格匹配，可以拋出派生類對象，讓基類捕獲，利用多態。具體看下面的異常體系

在函數調用鏈中異常棧展開匹配原則

1、throw拋出后，要確認自己是否在try里面，在的話才去找匹配的catch，然后跳到匹配的catch處

2、沒有匹配的catch，就跳出當前的函數棧，在調用該函數的函數棧中繼續找匹配的catch

3、如果在main函數中都沒有找到匹配的catch就會終止程序。而整個沿著調用鏈向上找匹配的catch的過程，就是棧展開。所以實際中，我們都會加個catch(...)，否則有異常沒捕獲就會直接終止程序。

4、在匹配的catch處執行完對應的語句后，會沿著當前的try ....catch之后的語句繼續執行。

3.2異常安全（還有一些異常重新拋出）

異常安全的核心問題就是在調用鏈非常長的情況下，異常會直接跳到catch，而這個過程很可能橫跨了很多個函數。

1、不要在構造函數里拋異常，因為拋異常會直接跳到catch。如果構造函數里面要進行初始化，最典型的就是開辟多段空間給多個指針變量，如果這個過程中拋異常了，導致有些指針變量沒有被初始化，仍然是野指針或空指針，那么析構函數在delete或者free的時候就會拋異常或者報錯。簡單點就是說可能會造成對象不完整或者沒有完全初始化

2、析構函數不要拋異常。因為析構函數負責資源的清理，如果在析構函數中拋異常，很可能導致內存泄漏等問題，比如某個空間沒有被delete掉。

3、異常經常會導致內存泄漏的問題。比如new和delete中間有一塊拋出了異常，導致直接跳到catch了，delete就不會執行，這樣就內存泄漏了，還會導致lock和unlock之間的死鎖問題（這個是線程的知識，看我linux和網絡的部分即可）

接下來是一種處理方法，利用異常重新拋出
void fa() {int a; cin >> a;if (a == 2){throw "wdawd";}else if (a == 3){throw 4;}else if (a == 4){string s("dwwdawda");throw s;}else if (a == 5){stack<int>s;s.push(2);throw s;}
}
void f() {int* x = new int;try {fa();}catch (...) {//不一定是...，只是最保險的就是這個，不管拋了什么異常都可以接受delete x;throw;//不管接受到什么異常，都通通重新拋出去。}
}
int main()
{try {f();}catch (const char* err){cout << err << endl;}catch (int x){cout << x << endl;}catch (const string& es){cout << es << endl;}catch (...) {cout << 231231 << endl;}return 0;
}
核心思路就是在關鍵位置提前捕獲，然后再重新拋出

比較惡心的情況：
void f() {int* x = new int;int *x1,x2;try {x1 = new int;try {x2 = new int;}catch (...) {delete x1;delete x;throw;}}catch (...) {delete x;throw;}delete x;delete x1;delete x2;
}
這個方法寫起來太麻煩了，可見這個方法也不是很好，依靠智能指針可以更加的高效處理這個問題
class SmartPtr {
public:SmartPtr(int *ptr):_ptr(ptr){}~SmartPtr() {delete _ptr;}
private:int* _ptr;
};
void f() {SmartPtr s1(new int);SmartPtr s2(new int);SmartPtr s3(new int);//這樣就可以依靠析構函數自動清理資源了。//就算拋了異常，s1、s2、s3是局部變量，在出了作用域會自動銷毀，調用它的析構函數}
3.3異常規范

出于上面的情況，98的時候，希望大家寫異常的時候規范一些。
// 這里表示這個函數會拋出A/B/C/D中的某種類型的異常
void fun() throw(A，B，C，D);
// 這里表示這個函數只會拋出A的異常
void* operator new (std::size_t size) throw (A);
// 這里表示這個函數不會拋出異常
void* operator delete (std::size_t size, void* ptr) throw();單單靠上面3個，還是會出問題，比如寫了拋abc,但實際上可能拋了d。
又比如函數深層調用，一層調一層那豈不是每一層函數都要寫好多的throw()。
而且因為考慮到兼容c語言的問題，這只能是個建議而不是規定。// C++11 中新增的noexcept，表示不會拋異常
thread() noexcept;
thread (thread&& x) noexcept;//通過這個簡化，只標記不會拋異常的函數。
但要小心的是，間接層加了noexcept,但這層函數調用的函數拋了異常，是不會檢測到的。而且一旦檢測到拋出了規定外的異常，編譯器也只是報錯。

4.自定義異常體系

在實際過程中，大家都是設計一個異常體系，否則的下不同組各自管自己拋異常，最后害慘了外面管異常的，因為catch(...)是不確定究竟是什么異常，所以通過設計異常體系，讓異常的信息更加的準確，方便處理。

?接下來是一個比較常見的異常體系

class Exception
{
public:Exception(const string& errmsg, int id):_errmsg(errmsg), _id(id){}virtual string what() const{return _errmsg;   //返回錯誤描述  }
protected:string _errmsg;//錯誤描述,比如基礎的錯誤信息，比如內存錯誤等等int _id; //錯誤id
};//這里會有一個類，比如說是數據庫開發組的。
class SqlException : public Exception
{
public:SqlException(const string& errmsg, int id, const string& sql):Exception(errmsg, id), _sql(sql){}virtual string what() const{string str = "SqlException:";//表明自己是什么錯誤類的str += _errmsg;str += "->";str += _sql;return str;//再基礎的錯誤信息基礎上，加上自己的額外備注信息，讓錯誤描述更加的準確}
private:const string _sql;
};//緩存組，具體做什么因人而異，主要是不同的組都會加上一串字符串，表示這個異常是
//哪個組負責的
class CacheException : public Exception
{
public:CacheException(const string& errmsg, int id):Exception(errmsg, id){}virtual string what() const{string str = "CacheException:";str += _errmsg;return str;}
};//網絡組的，記錄請求類型等等的
class HttpServerException : public Exception
{
public:HttpServerException(const string& errmsg, int id, const string& type):Exception(errmsg, id), _type(type){}virtual string what() const{string str = "HttpServerException:";str += _type;str += ":";str += _errmsg;return str;}
private:const string _type;
};

那么如何捕獲呢？

catch (const Exception& e) // 這里捕獲父類對象就可以{// 多態cout << e.what() << endl;}

利用繼承的特性，用父類對象的引用來接受派生類或者父類本身。

然后利用虛函數的特性，在滿足多態的情況下，如果接受的派生類，那么what調用的就是派生類的what，如果接受的是父類，就會調用父類的what。

5.c++標準庫的異常體系

?c++標準庫也是弄了一個異常體系。

圖片出自菜鳥編程。

6.異常優缺點

?1、優點

1、相比傳統的錯誤碼，異常可以更加清晰的展現出錯誤的信息，甚至包含堆棧的調用信息，這樣可以幫助更好的定位bug

2、錯誤碼必須通過層層的retrun返回錯誤碼，然后才能拿到錯誤碼，相比之下異常可以直接拿到信息，跳過中間的過程。

3、很多第三方的庫都包含了異常，使用的時候也得關注異常。

4、部分情況用異常更好，比如構造函數沒有返回值，只能拋異常。比如at這個函數，返回什么很重要，但問題是返回什么都可能不是錯誤信息，反而可能是一個正常的值，但確實下標越界了。

2、缺點

1、異常會導致程序的執行流亂跳，會非常混亂，尤其是運行時的時候拋異常就會亂跳。導致調試跟蹤以及分析程序的時候會非常困難。

2、異常有一定的性能開銷，不過在現在的硬件下，基本可以忽略不計。

3、c++沒有垃圾回收機制，資源需要自己管理，容易造成內存泄漏、死鎖等異常安全問題，想要解決，建議是rall（智能指針的內容）。

4、標準庫的異常體系定義的一般，導致所有人都是各自定義各自的，比較混亂。

5、異常需要盡量的規范使用，否則負責捕獲異常處理異常的人會很痛苦。主要是，所有的異常繼承自一個基類；函數是否拋異常、拋什么異常，都使用func() throw()的形式規范