C++中的異常實例詳解

更新時間：2022年02月07日 15:59:17 作者：wuqiongjin

異常處理是C++的一項語言機制,用于在程序中處理異常事件,下面這篇文章主要給大家介紹了關于C++中異常的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下

1. 異常

異常: 異常是面向對象與法處理錯誤的一種方式

1.1 C語言中處理錯誤的方式

返回錯誤碼 (很多API接口都會把錯誤碼放到errno當中)
終止程序 (assert終止、除零錯誤、段錯誤) [產生信號去終止進程]
C標準庫中setjump和longjump組合

1.2 C語言處理錯誤方式的缺陷

使用錯誤碼時，還需要查看錯誤碼表，去找每個錯誤碼的含義
當一個函數是通過返回值去輸出數據，那么發(fā)生錯誤的時候很難處理 (不好區(qū)設置發(fā)生錯誤時返回什么)
如果調用的函數棧很深時，使用錯誤碼去一層層返回時，處理起來很麻煩

//第2點
T& operator[](int index)
{
	//問題: 當訪問的下標index超出容器的范圍，此時該返回什么值?
    //解決方案: 可以再傳一個參數，用于獲取真正的結果(當輸出型參數), 返回值就用于判斷是否正確的返回了. 
    //實際上還是很麻煩
}

2. C++異常

2.1 異常相關關鍵字

try: try塊中放置可能會拋出異常的代碼，這段代碼被稱為保護代碼
catch: catch用于捕獲異常，catch塊中寫處理異常的代碼。它跟在try的后面，1個try后面可以跟多個catch
throw: throw用于拋出異常

try
{
    //保護代碼(可能會拋出異常的代碼)
}catch(ExceptionType e1)
{
    //處理異常
}catch(ExceptionType e2)
{
    //處理異常
}catch(ExceptionType eN)
{
    //處理異常
}

2.2 異常的使用

2.2.1 異常的拋出和匹配原則

異常是通過拋出對象而引發(fā)的，該對象的類型決定了應該匹配到哪個catch塊
異常的拋出會去匹配在整個調用鏈中與該對象類型相匹配且距離最近的那個
當異常拋出后，執(zhí)行流會直接跳轉到整個調用鏈當中能catch到異常的位置處，不能catch的地方就不會執(zhí)行了，所以這可能導致內存泄漏、文件流沒關閉、鎖未釋放**等情況。(free、fclose、unlock未執(zhí)行)
catch(…)可以用來捕獲任意類型對象的異常，一般用于表示"未知異常"或被用作異常的重新拋出時的接收catch塊
在拋出與捕獲的類型匹配上并不全都是類型相同才能匹配。我們可以使用基類去捕獲 —> 拋出的派生類的對象。 //會在下面具體講解

· 原則2：函數調用鏈中的異常 - 棧展開的匹配原則

查看throw是否在try的內部，如果存在能匹配到的catch語句，就跳轉到catch中進行異常的處理。
如果沒有匹配的catch就退出當前棧，去查找調用鏈當中的能夠匹配到的catch
如果在main函數中都沒有找到匹配的catch，則終止程序。

棧展開：上述的這個沿著調用鏈去逐個棧中查找匹配的catch語句的過程就是棧展開。

//代碼演示：f3()中拋出異常，該異常會被f1()捕捉，而在main函數中的catch是無法捕捉到的
void f3()
{
	throw 123;
}
void f2()
{
    f3();
}
void f1()
{
    try
    {
        f2();
        cout << "f1() not catched Exception!" << endl;
    }catch(int& err)
    {
        cout << "f1()-err: " << err << endl;
    }
}

int main()
{
    try
    {
        f1();
        cout << "main not catched Exception!" << endl;
    }catch(int& err)
    {
        cout << "main-err: " << err << endl; 
    }
    return 0;
}

注意：

拋出異常對象后，會生成一個異常對象的拷貝(可能是一個臨時對象)，這個拷貝的臨時對象在被catch后會被銷毀。異常的執(zhí)行流執(zhí)行順序：從throw拋出異常處跳轉到調用鏈中能夠匹配的catch語句中；然后執(zhí)行catch塊中的代碼；catch執(zhí)行完畢后在當前函數棧中順序執(zhí)行。(整個調用鏈中沒有匹配的就終止程序)

2.3 異常的重新拋出

可能會存在單個catch不能完全處理一個異常的情況，在經過一些校正處理后，我們希望將該異常交給外層調用鏈中的函數來處理，此時我們可以通過在catch中重新拋出異常的方式把異常傳遞給調用鏈的上層函數處理。

//在SecondThrowException()函數中我們要delete[]動態(tài)開辟(new出來)的空間，
//如果不使用異常的重新拋出的話，就會造成內存泄漏問題 (也可以使用RAII)
void FirstThrowException()
{
    throw "First throw a exception!";
}

void SecondThrowException()
{
    int* arr = new int[10];
    try
    {
        FirstThrowException();
    }catch(...)
    {
        cout << "Delete[] arr Success!" << endl;
        delete[] arr;
        throw;
    }
}

void SoluteException()
{
    try
    {
        SecondThrowException();
    }catch(const char* err)
    {
        cout << err << endl;
    }
}

int main()
{
    SoluteException();
    return 0;
}

2.4 自定義異常體系

自定義異常體系實際上就是自己定義的一套異常管理體系，很多公司當中都會自定義自己的異常體系以便于規(guī)范的進行異常管理。它主要用到了我們在上面所說的一條規(guī)則: 我們只需要拋出派生類對象，然后捕獲基類對象就可以了。這樣的拋出與捕獲方式非常便于異常的處理。

class MyException
{
public:
	MyException(string errmsg, int id)
		:_errmsg(errmsg),
		 _id(id)
	{}
	
	virtual string what() const = 0;	//必須放到public下才能讓類外定義的成員訪問到
protected:
	int _id;		//錯誤碼
	string _errmsg;	//存放錯誤信息
	//list<StackInfo> _traceStack;	//存放調用鏈的信息
    //...
};

class CacheException : public MyException
{
public:
	CacheException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "CacheException!: " + _errmsg;
	}
};

class NetworkException : public MyException
{
public:
	NetworkException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "NetworkException!: " + _errmsg;
	}
};

class SqlException : public MyException
{
public:
	SqlException(string errmsg, int id)
		:MyException(errmsg, id)
	{}

	virtual string what() const
	{
		return "SqlException!: " + _errmsg;
	}
};

int main()
{
	try
	{
		//拋出任意的派生類對象
		throw SqlException("sql open failed", 10);
	}
    catch (const MyException& e)	//只需要捕獲基類對象
	{
		cout << e.what() << endl;	//這里實際上完成了一個多態(tài)
	}
	catch (...)	//走到這里說明出現未知異常
	{
		cout << "Unknown Exception!" << endl;
	}

	return 0;
}

2.5 異常安全

最好不要在構造函數中拋異常，構造函數是完成對象的構造和初始化的，在里面拋異?？赡軙е聦ο髽嬙觳煌暾驔]有完全初始化。 (可能會造成內存泄漏)
最好不要在析構函數中拋異常，析構函數是完成資源的清理工作的，在里面拋異常可能導致資源沒清完就結束了函數調用，從而導致內存泄漏、句柄未關閉等問題。
注意new、fopen、lock的使用

2.6 異常規(guī)范

異常規(guī)范的指定是為了讓使用者知道函數可能拋出哪些異常，用法：

void func1() throw(); //表示該函數不會拋異常
void func2() noexcept; //等價于throw()  表示該函數不會拋異常
void func3() throw(std::bad_alloc);	//表示該函數只會拋出bad_alloc的異常
void func4() throw(int, double, string); //表示該函數會拋出int/double/string類型中的某種異常

2.7 C++標準庫的異常體系

C++提供了一系列標準的異常，定義在中，下面是這些異常的組織形式。

異常	描述
std::exception	該異常是所有標準 C++ 異常的父類。
std::bad_alloc	該異常可以通過 new 拋出。
std::bad_cast	該異?？梢酝ㄟ^ dynamic_cast 拋出。
std::bad_exception	這在處理 C++ 程序中無法預期的異常時非常有用。
std::bad_typeid	該異?？梢酝ㄟ^ typeid 拋出。
std::logic_error	理論上可以通過讀取代碼來檢測到的異常。
std::domain_error	當使用了一個無效的數學域時，會拋出該異常。
std::invalid_argument	當使用了無效的參數時，會拋出該異常。
std::length_error	當創(chuàng)建了太長的 std::string 時，會拋出該異常。
std::out_of_range	該異?？梢酝ㄟ^方法拋出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error	理論上不可以通過讀取代碼來檢測到的異常。
std::overflow_error	當發(fā)生數學上溢時，會拋出該異常。
std::range_error	當嘗試存儲超出范圍的值時，會拋出該異常。
std::underflow_error	當發(fā)生數學下溢時，會拋出該異常。

int main()
{
	try
    {
        vector<int> v(5);
        v.at(5) = 0;	//v.at(下標) = v[下標] + 拋異常
    }
    catch(const exception& e)
    {
        cout << e.what() << endl;
    }
    catch(...)
    {
		cout << "Unknown Exception!" << endl;        
    }
}