C++異常使用詳解(看這一篇就夠了)

更新時間：2023年10月20日 10:36:07 作者：Insisting.

C++中的異常是指在程序執(zhí)行過程中發(fā)生錯誤,導(dǎo)致程序無法正常運行的情況,下面這篇文章主要給大家介紹了關(guān)于C++異常使用的相關(guān)資料,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下

一、異常的概念

異常是一種處理錯誤的方式，當(dāng)一個函數(shù)發(fā)現(xiàn)自己無法處理的錯誤時就可以拋出異常，讓函數(shù)的直接或間接的調(diào)用者處理這個錯誤。

throw:當(dāng)問題出現(xiàn)時，程序會拋出一個異常。這是通過使用 throw 關(guān)鍵字來完成的。
catch: 在你想要處理問題的地方，通過異常處理程序捕獲異常，catch 關(guān)鍵字用于捕獲異常，可以有多個catch進(jìn)行捕獲。
try: try 塊中的代碼標(biāo)識將被激活的特定異常,它后面通常跟著一個或多個 catch 塊。

語法：

try
{
    // 保護(hù)的標(biāo)識代碼
}
catch( ExceptionName e1 )
{
    // catch 塊
}
catch( ExceptionName e2 )
{
    // catch 塊
}
catch( ExceptionName eN )
{
    // catch 塊
}

二、異常的使用

1.異常的拋出和捕獲原則

1.異常是通過拋出對象而引發(fā)的，該對象的類型決定了應(yīng)該激活哪個catch的處理代碼。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
using namespace std;

double Division(int a, int b)
{
	//當(dāng)b == 0時拋出異常
	if (b == 0)
		throw "Division by zero condition!";
		//throw 1;
	else
		return ((double)a / (double)b);
}

void func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	try {
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const int errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

當(dāng)拋出的異常時char* 類型時

在這里插入圖片描述

當(dāng)拋出異常換成整形時

在這里插入圖片描述

2.被選中的處理代碼是調(diào)用鏈中與該對象類型匹配且離拋出異常位置最近的那一個

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
using namespace std;

double Division(int a, int b)
{
	try
	{
		//當(dāng)b == 0時拋出異常
		if (b == 0)
			throw "Division by zero condition!";
		else
			return ((double)a / (double)b);
	}
	catch(const char* errmsg)
	{
		cout << "Division:" << errmsg << endl;
	}
}

void func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	try {
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const int errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

3.拋出異常對象后，會生成一個異常對象的拷貝，因為拋出的異常對象可能是一個臨時對象，所以會生成一個拷貝對象，這個拷貝的臨時對象會在被catch以后銷毀。（這里的處理類似于函數(shù)的傳值返回）

4.catch(…)可以捕獲任意類型的異常，問題是不知道異常錯誤是什么。

void fun1()
{
	throw "錯誤";
}

int main()
{
	try {
		fun1();
	}
	catch(const int errmsg)
	{
		cout << errmsg;
	}
	catch (...)
	{
		cout << "未知錯誤" << endl;
	}
}

5.實際中拋出和捕獲的匹配原則有個例外，并不都是類型完全匹配，可以拋出的派生類對象，使用基類捕獲，這個在實際中非常實用，以后主要用到的也是這種方式

2.在函數(shù)調(diào)用鏈中異常棧展開匹配原則

1.首先檢查throw本身是否在try塊內(nèi)部，如果是再查找匹配的catch語句。如果有匹配的，則調(diào)到catch的地方進(jìn)行處理。
2.沒有匹配的catch則退出當(dāng)前函數(shù)棧，繼續(xù)在調(diào)用函數(shù)的棧中進(jìn)行查找匹配的catch。
3.如果到達(dá)main函數(shù)的棧，依舊沒有匹配的，則終止程序。上述這個沿著調(diào)用鏈查找匹配的catch子句的過程稱為棧展開。所以實際中我們最后都要加一個catch(…)捕獲任意類型的異常，否則當(dāng)有異常沒捕獲，程序就會直接終止。
4.找到匹配的catch子句并處理以后，會繼續(xù)沿著catch子句后面繼續(xù)執(zhí)行。

3.異常規(guī)范

1.異常規(guī)格說明的目的是為了讓函數(shù)使用者知道該函數(shù)可能拋出的異常有哪些。可以在函數(shù)的
后面接throw(類型)，列出這個函數(shù)可能拋擲的所有異常類型
2.函數(shù)的后面接throw()，表示函數(shù)不拋異常。
3.若無異常接口聲明，則此函數(shù)可以拋擲任何類型的異常。

// 這里表示這個函數(shù)會拋出A/B/C/D中的某種類型的異常
void fun() throw(A，B，C，D);
// 這里表示這個函數(shù)只會拋出bad_alloc的異常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 這里表示這個函數(shù)不會拋出異常
void* operator new (std::size_t size, void* ptr) throw();

// C++11 中新增的noexcept，表示不會拋異常
thread() noexcept;

4.異常安全

構(gòu)造函數(shù)完成對象的構(gòu)造和初始化，最好不要在構(gòu)造函數(shù)中拋出異常，否則可能導(dǎo)致對象不完整或沒有完全初始化
析構(gòu)函數(shù)主要完成資源的清理，最好不要在析構(gòu)函數(shù)內(nèi)拋出異常，否則可能導(dǎo)致資源泄漏(內(nèi)存泄漏、句柄未關(guān)閉等)
C++中異常經(jīng)常會導(dǎo)致資源泄漏的問題，比如在new和delete中拋出了異常，導(dǎo)致內(nèi)存泄漏，在lock和unlock之間拋出了異常導(dǎo)致死鎖，C++經(jīng)常使用RAII來解決以上問題。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<windows.h>
using namespace std;

double Division(int a, int b)
{
	//當(dāng)b == 0時拋出異常
	if (b == 0)
		throw "Division by zero condition!";
	else
		return ((double)a / (double)b);
}

void func()
{
	int* array = new int[10];
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
	cout << "delete []" << array << endl;
	delete[] array;
}

int main()
{
	try {
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const int errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

正常情況，沒有異常

有異常

如果出現(xiàn)了在new和delete中間拋出異?；蛘咧虚g的某個函數(shù)拋出異常，會導(dǎo)致程序直接跳轉(zhuǎn)到catch的地方而無法實現(xiàn)delete，出現(xiàn)內(nèi)存泄漏

5.異常的重新拋出

有可能單個的catch不能完全處理一個異常，在進(jìn)行一些校正處理以后，希望再交給更外層的調(diào)用鏈函數(shù)來處理，catch則可以通過重新拋出將異常傳遞給更上層的函數(shù)進(jìn)行處理。

double Division(int a, int b)
{
    // 當(dāng)b == 0時拋出異常
    if (b == 0)
    {
        throw "Division by zero condition!";
    }
    return (double)a / (double)b;
}
void Func()
{
    // 這里可以看到如果發(fā)生除0錯誤拋出異常，另外下面的array沒有得到釋放。
    // 所以這里捕獲異常后并不處理異常，異常還是交給外面處理，這里捕獲了再重新拋出去。
    int* array = new int[10];
    try 
    {
        int len, time;
        cin >> len >> time;
        cout << Division(len, time) << endl;
    }
    catch (...)
    {
        cout << "delete []" << array << endl;
        delete[] array;
        throw; // 重新拋出異常，且內(nèi)容不變
    }
    // ...
    cout << "delete []" << array << endl;
    delete[] array;
}
int main()
{
    try
    {
        Func();
    }
    catch (const char* errmsg) // 捕獲Func重新拋出的異常
    {
        cout << errmsg << endl;
    }
    return 0;
}

三、異常的優(yōu)缺點

異常的優(yōu)點

異常對象定義好了，相比錯誤碼的方式可以清晰準(zhǔn)確的展示出錯誤的各種信息，甚至可以包含堆棧調(diào)用的信息，這樣可以幫助更好的定位程序的bug。
返回錯誤碼的傳統(tǒng)方式有個很大的問題就是，在函數(shù)調(diào)用鏈中，深層的函數(shù)返回了錯誤，那么我們得層層返回錯誤，最外層才能拿到錯誤.
很多的第三方庫都包含異常，比如boost、gtest、gmock等等常用的庫，那么我們使用它們也需要使用異常。
很多測試框架都使用異常，這樣能更好的使用單元測試等進(jìn)行白盒的測試。
部分函數(shù)使用異常更好處理，比如構(gòu)造函數(shù)沒有返回值，不方便使用錯誤碼方式處理。比如T&operator這樣的函數(shù)，如果pos越界了只能使用異?；蛘呓K止程序處理，沒辦法通過返回值表示錯誤。

異常的缺點

異常會導(dǎo)致程序的執(zhí)行流亂跳，并且非常的混亂，并且是運行時出錯拋異常就會亂跳。這會導(dǎo)致我們跟蹤調(diào)試時以及分析程序時，比較困難。
異常會有一些性能的開銷。當(dāng)然在現(xiàn)代硬件速度很快的情況下，這個影響基本忽略不計。
C++沒有垃圾回收機(jī)制，資源需要自己管理。有了異常非常容易導(dǎo)致內(nèi)存泄漏、死鎖等異常安全問題。這個需要使用RAII來處理資源的管理問題。學(xué)習(xí)成本較高。
C++標(biāo)準(zhǔn)庫的異常體系定義得不好，導(dǎo)致大家各自定義各自的異常體系，非常的混亂。
異常盡量規(guī)范使用，否則后果不堪設(shè)想，隨意拋異常，外層捕獲的用戶苦不堪言。所以異常規(guī)范有兩點：一、拋出異常類型都繼承自一個基類。二、函數(shù)是否拋異常、拋什么異常，都使用 func（）throw();的方式規(guī)范化。