續上節內容 c++中的例外處理 ...
目錄
1、在main() 函式中拋出例外會發生什么
2、在解構式中拋出例外會發生什么
3、函式的例外規格說明
4、動態記憶體申請結果的分析
5、關于 new 關鍵字的新用法
1、在main() 函式中拋出例外會發生什么
由上節中的 例外拋出（throw exception）的邏輯分析 可知，例外拋出后，會順著函式呼叫堆疊向上傳播，在這期間，若例外被捕獲，則程式正常運行；若例外在 main() 函式中依然沒有被捕獲，也就是說在 main() 函式中拋出例外會發生什么呢？（程式崩潰，但因編譯器的不同，結果也會略有差異）
1 #include <iostream> 2 #include <cstdlib> 3 4 using namespace std; 5 6 class Test 7 { 8 public: 9 Test() 10 { 11 cout << "Test()" << endl; 12 } 13 14 ~Test() 15 { 16 cout << "~Test()" << endl; 17 } 18 }; 19 20 int main() 21 { 22 cout << "main() begin..." << endl; 23 24 static Test t; 25 26 throw 1; 27 28 cout << "main() end..." << endl; 29 30 return 0; 31 }在 main() 函式中拋出例外
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++下運行，結果如下：
main() begin...
Test()
terminate called after throwing an instance of 'int'
Aborted (core dumped)
在 vs2013下運行，結果如下：
main() begin...
Test()
彈出例外除錯對話框
從運行結果來看，在 main() 中拋出例外后會呼叫一個全域的 terminate() 結束函式，在 terminal() 函式中不同編譯器處理的方式有所不同，
c++ 支持自定義結束函式，通過呼叫 set_terminate() 函式來設定自定義的結束函式，此時系統默認的 terminal() 函式就會失效；
（1）自定義結束函式的特點：與默認的 terminal() 結束函式 原型一樣，無參無回傳值；
關于使用 自定義結束函式的注意事項：
1）不能在該函式中再次拋出例外，這是最后一次處理例外的機會了；
2）必須以某種方式結束當前程式，如 exit(1)、abort();
exit()：結束當前的程式，并且可以確保所有的全域物件和靜態區域物件全部都正常析構；
abort()：例外終止一個程式，并且例外終止的時候不會呼叫任何物件的解構式；
（2）set_terminate() 函式的特點：1）引數型別為函式指標 void(*)()；2）回傳值為自定義的 terminate() 函式入口地址；
1 #include <iostream> 2 #include <cstdlib> 3 4 using namespace std; 5 6 class Test 7 { 8 public: 9 Test() 10 { 11 cout << "Test()" << endl; 12 } 13 14 ~Test() 15 { 16 cout << "~Test()" << endl; 17 } 18 }; 19 20 void mterminate() 21 { 22 cout << "void mterminate()" << endl; 23 abort(); // 例外終止一個程式，不會析構任何物件 24 //exit(1); // 結束當前程式，但會析構所有的全域和靜態區域物件 25 } 26 27 int main() 28 { 29 terminate_handler f = set_terminate(mterminate); 30 31 cout << "terminate() 函式的入口地址 = " << f << "::" << mterminate << endl; 32 33 cout << "main() begin..." << endl; 34 35 static Test t; 36 37 throw 1; 38 39 cout << "main() end..." << endl; 40 41 return 0; 42 } 43 /** 44 * 以 exit(1) 結束程式時的運行結果： 45 * terminate() 函式的入口地址 = 1::1 46 * main() begin... 47 * Test() 48 * void mterminate() 49 * ~Test() 50 */ 51 52 /** 53 * 以 abort() 結束程式時的運行結果： 54 * terminate() 函式的入口地址 = 1::1，《為什么全域函式的地址都是 1 ？》 55 * main() begin... 56 * Test() 57 * void mterminate() 58 * Aborted (core dumped) 59 */自定義結束函式測驗案例
2、在解構式中拋出例外會發生什么
一般而言，在解構式中銷毀所使用的資源，若在資源銷毀的程序中拋出例外，那么會導致所使用的資源無法完全銷毀；若對這一解釋深入挖掘，那么會發生什么呢？
試想程式在 main() 函式中拋出了例外，然而該例外并沒有被捕獲，那么該例外就會觸發系統默認的結束函式 terminal()；因為不同編譯器對 terminal() 函式的內部實作有所差異，
（1）若 terminal() 函式是以 exit(1) 這種方式結束程式的話，那么就會有可能呼叫到解構式，而此時的解構式中又拋出了一個例外，就會導致二次呼叫 terminal() 函式，后果不堪設想（類似堆空間的二次釋放），但是，強大的 windows、Linux系統會幫我們解決這個問題，不過在一些嵌入式的作業系統中可能就會產生問題，
（2）若 terminal() 函式是以 abort() 這種方式結束程式的話，就不會發生（1）中的情況，這就是 g++ 編譯器為什么會這么做的原因了，
注：terminal() 結束函式是最后處理例外的一個函式，所以該函式中不可以再次拋出例外，而（1）中就是違反了這條規則；
若在 terminal() 結束函式中拋出例外，就會導致二次呼叫 terminal() 結束函式，
結論：在解構式中拋出例外時，若 terminate() 函式中以 exit() 這種方式結束程式的話會很危險，有可能二次呼叫 terminate() 函式，甚至死回圈，
1 #include <iostream> 2 #include <cstdlib> 3 4 using namespace std; 5 6 class Test 7 { 8 public: 9 Test() 10 { 11 cout << "Test()" << endl; 12 } 13 14 ~Test() 15 { 16 cout << "~Test()" << endl; 17 18 throw 1； // 代碼分析：會二次呼叫 mterminate() 19 } 20 }; 21 22 void mterminate() 23 { 24 cout << "void mterminate()" << endl; 25 exit(1); // 結束當前程式，但會析構所有的全域和靜態區域物件 26 } 27 28 int main() 29 { 30 set_terminate(mterminate); 31 32 cout << "main() begin..." << endl; 33 34 static Test t; 35 36 throw 1; 37 38 cout << "main() end..." << endl; 39 40 return 0; 41 }在解構式中拋出例外案例測驗
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++下運行，結果如下：
main() begin...
Test()
void mterminate() // 在 main() 函式中第一次拋出例外，呼叫 自定義結束函式 mterminate()
~Test() // exit(1) 程式結束時，呼叫了解構式，在解構式中再次拋出了例外，會呼叫 abort() 函式
Aborted (core dumped) // 注：一些舊版本的編譯器可能會呼叫 自定義結束函式 mterminate()，此行顯示 void mterminate()
在 vs2013下運行，結果如下：
main() begin...
Test()
void mterminate()
~Test() // exit(1) 程式結束時，呼叫了解構式，在解構式中再次拋出了例外，會 彈出例外除錯對話框
彈出例外除錯對話框 // 注：一些舊版本的編譯器可能會呼叫 自定義結束函式 mterminate()，此行顯示 void mterminate()
結論：新版本的編譯器對 解構式中拋出例外這種行為 做了優化，直接讓程式例外終止，
3、函式的例外規格說明
如何判斷某個函式是否會拋出例外，或許有很多辦法，如查看函式的實作（可惜第三方庫不提供函式實作）、查看技術檔案（可能查看的檔案與當前所使用的函式版本不一致），但剛才列舉的這些方法都會存在缺陷，其實有一種更為簡單高效的方法，就是直接通過例外宣告來判斷這個函式是否會拋出例外，簡稱為函式的例外規格說明，
例外宣告作為函式宣告的修飾符，寫在引數串列的后面；
1 /* 可能拋出任何例外 */ 2 void func1(); 3 4 /* 只能拋出的例外型別：char 和 int */ 5 void func2() throw(char, int); 6 7 /* 不拋出任何例外 */ 8 void func3() throw();
例外規格說明的意義：
（1）提示函式呼叫者必須做好例外處理的準備；（如果想知道呼叫的函式會拋出哪些型別的例外時，只用打開頭檔案看看這個函式是怎么宣告的就可以了；）
（2）提示函式的維護者不要拋出其它例外；
（3）例外規格說明是函式介面的一部分；（用于說明這個函式如何正確的使用；）
1 #include <iostream> 2 3 using namespace std; 4 5 void func() throw(int) 6 { 7 cout << "func()" << endl; 8 9 throw 'c'; 10 } 11 12 int main() 13 { 14 try 15 { 16 func(); 17 } 18 catch(int) 19 { 20 cout << "catch(int)" << endl; 21 } 22 catch(char) 23 { 24 cout << "catch(char)" << endl; 25 } 26 27 return 0; 28 }例外規格之外的例外測驗案例
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++下運行，結果如下：
func()
terminate called after throwing an instance of 'char'
Aborted (core dumped)
在 vs2013下運行，結果如下：
func()
catch(char) // 竟然捕獲了該例外，說明不受例外規格說明限制
通過對上述代碼結果的再次研究，我們發現在 g++中，當例外不在函式例外規格說明中，就會呼叫一個 全域函式 unexpected()，在該函式中再呼叫默認的全域結束函式 terminate()；
但在 vs2013中，例外并不會受限于函式例外規格說明的限制，
結論：g++ 編譯器遵循了c++規范，然而 vs2013 編譯器并不受限于這個約束，
提示：不同編譯器對函式例外規格說明的處理方式有所不同，所以在進行專案開發時，有必要測驗當前所使用的編譯器，
c++ 中支持自定義例外函式；通過呼叫 set_unexpected() 函式來設定自定義例外函式，此時系統默認的 全域函式 unexpected() 就會失效；
（1）自定義例外函式的特點：與默認的 全域函式 unexpected() 原型一樣，無參無回傳值；
（2）關于使用 自定義例外函式 的注意事項：
可以在函式中拋出例外（當例外符合觸發函式的例外規格說明時，恢復程式執行；否則，呼叫全域 terminate() 函式結束程式）；
（3）set_unexpected() 函式的特點：1）引數型別為函式指標 void(*)()；2）回傳值為自定義的 unexpected() 函式入口地址；
1 #include <iostream> 2 #include <cstdlib> 3 4 using namespace std; 5 6 void m_unexpected() 7 { 8 cout << "void m_unexpected()" << endl; 9 10 throw 1; // 2 這個例外符合例外規格說明，所以可以被捕獲 11 // terminate(); // 若這么寫，與上個程式的運行結果相同 12 } 13 14 void func() throw(int) 15 { 16 cout << "func()" << endl; 17 18 throw 'c'; // 1 由于不符合例外規格說明，此時會呼叫 m_unexpected() 函式 19 } 20 21 int main() 22 { 23 set_unexpected(m_unexpected); 24 25 try 26 { 27 func(); 28 } 29 catch(int) 30 { 31 cout << "catch(int)" << endl; 32 } 33 catch(char) 34 { 35 cout << "catch(char)" << endl; 36 } 37 38 return 0; 39 }自定義 unexpected() 函式的測驗案例
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++下運行，結果如下：
func()
void m_unexpected()
catch(int) // 由于自定義例外函式 m_unexpected() 中拋出的例外 throw 1 符合函式例外規格說明，所以該例外被捕獲
在 vs2013下運行，結果如下：
func()
catch(char) // vs2013 沒有遵循c++規范，不受例外規格說明的限制，直接捕獲函式例外規格說明中 throw ‘c’這個例外
結論：（g++）unexpected() 函式是正確處理例外的最后機會，如果沒有抓住，terminate() 函式會被呼叫，當前程式以例外告終；
（vs2013）沒有函式例外規格說明的限制，所有的函式都可以拋出任意例外，
4、動態記憶體申請結果的分析
在 c 語言中，使用 malloc 函式進行動態記憶體申請時，若成功，則回傳對應的記憶體首地址；若失敗，則回傳 NULL 值，
在 c++規范中，通過多載 new、new[] 運算子去動態申請足夠大的記憶體空間時，
（1）若成功，則在獲取的空間中呼叫建構式創建物件，并回傳物件地址；
（2）若失敗（記憶體空間不足），根據編譯器的不同，結果也會不同；
1）回傳 NULL 值；（早期編譯器的行為，不屬于 c++ 規范）
2）拋出 std::bad_alloc 例外；（后期的編譯器會拋出例外，一些早期的編譯器依然回傳 NULL 值）
注：不同編譯器 對如何拋出例外 也是不確定的，c++ 規范是在 new_handler() 函式中拋出 std::bad_alloc 例外，而 new_handler() 函式是在記憶體申請失敗時自動呼叫的，
當記憶體空間不足時，會呼叫全域的 new_hander() 函式，呼叫該函式的意義就是讓我們有機會整理出足夠的記憶體空間；所以，我們可以自定義 new_hander() 函式，并通過全域函式 set_new_hander() 去設定自定義 new_hander() 函式，（通過實驗證明， 有些編譯器沒有定義全域的 new_hander() 函式，比如 vs2013、g++ ，見案例1 ）
特別注意：set_new_hander() 的回傳值是默認的全域 new_hander() 函式的入口地址，
而 set_terminate() 函式的回傳值是自定義 terminate() 函式的入口地址；
set_unexpected() 函式的回傳值是自定義 unexpected() 函式的入口地址，
1 #include <iostream> 2 3 using namespace std; 4 5 void my_new_handler() 6 { 7 cout << "void my_new_handler()" << endl; 8 } 9 10 int main(int argc, char *argv[]) 11 { 12 // 若編譯器有全域 new_handler() 函式，則 func ！= NULL，否則，func == NULL； 13 new_handler func = set_new_handler(my_new_handler); 14 15 try 16 { 17 cout << "func = " << func << endl; 18 19 if( func ) 20 { 21 func(); 22 } 23 } 24 catch(const bad_alloc&) 25 { 26 cout << "catch(const bad_alloc&)" << endl; 27 } 28 29 return 0; 30 }案例1：證明 編譯器是否定義了全域 new_handler() 函式
將上述代碼在不同的編譯器上運行，結果也會不同；
在 vs2013 和 g++下運行，結果如下：
func = 0 // => vs2013 and g++ 中沒有定義 全域 new_handler() 函式
在 BCC下運行，結果如下：
func = 00401468
catch(const bad_alloc&) // 在 BCC 中定義了全域 new_handler() 函式，并在該函式中拋出了 std::bad_alloc 例外
1 #include <iostream> 2 #include <new> 3 #include <cstdlib> 4 #include <exception> 5 6 using namespace std; 7 8 class Test 9 { 10 int m_value; 11 public: 12 Test() 13 { 14 cout << "Test()" << endl; 15 16 m_value = https://www.cnblogs.com/nbk-zyc/p/0; 17 } 18 19 ~Test() 20 { 21 cout << "~Test()" << endl; 22 } 23 24 void* operator new (size_t size) 25 { 26 cout << "operator new: " << size << endl; 27 28 return NULL; 29 } 30 31 void operator delete (void* p) 32 { 33 cout << "operator delete: " << p << endl; 34 35 free(p); 36 } 37 38 void* operator new[] (size_t size) 39 { 40 cout << "operator new[]: " << size << endl; 41 42 return NULL; 43 } 44 45 void operator delete[] (void* p) 46 { 47 cout << "operator delete[]: " << p << endl; 48 49 free(p); 50 } 51 }; 52 53 int main(int argc, char *argv[]) 54 { 55 Test* pt = new Test(); 56 57 cout << "pt = " << pt << endl; 58 59 delete pt; 60 61 pt = new Test[5]; 62 63 cout << "pt = " << pt << endl; 64 65 delete[] pt; 66 67 return 0; 68 }案例2：不同編譯器在記憶體申請失敗時的表現
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++下運行，結果如下：
operator new: 4
Test() // 由于堆空間申請失敗，回傳 NULL 值，接著又在這片失敗的空間上創建物件，當執行到 m_value = https://www.cnblogs.com/nbk-zyc/p/0;時（相當于在 非法地址上賦值），編譯器報 段錯誤
Segmentation fault (core dumped)
在 vs2013下運行，結果如下：
operator new: 4
pt = 00000000
operator new[]: 24
pt = 00000000
在 BCC下運行，結果如下：
operator new: 4
pt = 00000000
operator new[]: 24
pt = 00000000
operator delete[]: 00000000
總結：在 g++ 編譯器中，記憶體空間申請失敗，也會繼續呼叫建構式創建物件，這樣會產生 段錯誤；在 vs2013、BCC 編譯器中，記憶體空間申請失敗，直接回傳NULL，
為了讓不同編譯器在記憶體申請時的行為統一，所以必須要多載 new、delete 或者 new[]、delete[] 運算子，當記憶體申請失敗時，直接回傳 NULL 值，而不是拋出 std::bad_alloc 例外，這就必須通過 throw() 修飾 記憶體申請函式，
1 #include <iostream> 2 #include <new> 3 #include <cstdlib> 4 #include <exception> 5 6 using namespace std; 7 8 class Test 9 { 10 int m_value; 11 public: 12 Test() 13 { 14 cout << "Test()" << endl; 15 16 m_value = https://www.cnblogs.com/nbk-zyc/p/0; 17 } 18 19 ~Test() 20 { 21 cout << "~Test()" << endl; 22 } 23 24 void* operator new (size_t size) throw() 25 { 26 cout << "operator new: " << size << endl; 27 28 return NULL; 29 } 30 31 void operator delete (void* p) 32 { 33 cout << "operator delete: " << p << endl; 34 35 free(p); 36 } 37 38 void* operator new[] (size_t size) throw() 39 { 40 cout << "operator new[]: " << size << endl; 41 42 return NULL; 43 } 44 45 void operator delete[] (void* p) 46 { 47 cout << "operator delete[]: " << p << endl; 48 49 free(p); 50 } 51 }; 52 53 int main(int argc, char *argv[]) 54 { 55 Test* pt = new Test(); 56 57 cout << "pt = " << pt << endl; 58 59 delete pt; 60 61 pt = new Test[5]; 62 63 cout << "pt = " << pt << endl; 64 65 delete[] pt; 66 67 return 0; 68 }案例3：（優化）不同編譯器在記憶體申請失敗時的表現
通過測驗，g++、vs2013、BCC 3款編譯器的運行結果一樣，輸出結果如下：
operator new: 4
pt = 00000000
operator new[]: 24
pt = 00000000
5、關于 new 關鍵字的新用法
（1）nothrow 關鍵字
1 #include <iostream> 2 #include <exception> 3 4 using namespace std; 5 6 void func1() 7 { 8 try 9 { 10 int* p = new(nothrow) int[-1]; 11 12 cout << p << endl; 13 14 delete[] p; 15 } 16 catch(const bad_alloc&) 17 { 18 cout << "catch(const bad_alloc&)" << endl; 19 } 20 21 cout << "--------------------" << endl; 22 23 try 24 { 25 int* p = new int[-1]; 26 27 cout << p << endl; 28 29 delete[] p; 30 } 31 catch(const bad_alloc&) 32 { 33 cout << "catch(const bad_alloc&)" << endl; 34 } 35 } 36 37 int main(int argc, char *argv[]) 38 { 39 func1(); 40 41 return 0; 42 }nothrow 關鍵字的使用
將上述代碼在不同的編譯器上運行，結果也會不同；
在 g++、BCC下運行，結果如下：
0 // 使用了 nothrow 關鍵字，在動態記憶體申請失敗時，直接回傳 NULL
--------------------
catch(const bad_alloc&) // 沒有 nothrow 關鍵字，動態記憶體申請失敗時，拋出 std::bad_alloc 例外
在 vs2013下編譯失敗：
原因是 記憶體申請太大，即陣列的總大小不得超過 0x7fffffff 位元組；
結論：nothrow 關鍵字的作用：無論動態記憶體申請結果是什么，都不會拋出例外，并且這種現象在不同編譯器之間也會有差異，
（2）通過 new 在指定的地址上創建物件
1 #include <iostream> 2 3 using namespace std; 4 5 void func2() 6 { 7 int bb[2] = {0}; 8 9 struct ST 10 { 11 int x; 12 int y; 13 }; 14 15 // 通過 new 在指定的地址上創制物件 16 // 將動態記憶體ST 創建到堆疊空間上（int bb[2] = {0}），但要保證二者的記憶體模型相同，此處是 8 bytes 17 ST* pt = new(bb) ST(); 18 19 pt->x = 1; 20 pt->y = 2; 21 22 cout << bb[0] << "::" << bb[1] << endl; 23 24 bb[0] = 3; 25 bb[1] = 4; 26 27 cout << pt->x << "::" << pt->y << endl; 28 29 pt->~ST(); // 由于指定了創建物件的空間，必選顯示的呼叫解構式 30 } 31 32 int main(int argc, char *argv[]) 33 { 34 func2(); 35 36 return 0; 37 }通過 new 在指定的地址上創制物件
在 g++、vs2013、BCC下運行，結果如下：
1::2
3::4
動態記憶體申請的結論：
（1）不同的編譯器在動態記憶體分配上的實作細節不同；
（2）編譯器可能重定義 new 的實作，并在實作中拋出 bad_alloc 例外；（vs2013、g++）
（3）編譯器的默認實作中，可能沒有設定全域的 new_handler() 函式；（vs2013、g++）
（4）對于移植性要求高的代碼，需要考慮 new 的具體細節；
我們可以進一步驗證上述結論，就以 vs2013 舉例，在編譯器的安裝包找到 new.cpp、new2.cpp 這兩個檔案（文 件路徑：C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\crt\src）,分析其原始碼發現，在記憶體申請失敗時，會呼叫 _callnewh(cb) 函式，該函式可以通過如下方式查看：https://docs.microsoft.com/zh-cn/cpp/c-runtime-library/reference/callnewh?view=vs-2015；
所以在 vs中，當動態記憶體申請失敗時，會拋出 std::bad_alloc例外，而不會回傳 NULL 值；
1 #ifdef _SYSCRT 2 #include <cruntime.h> 3 #include <crtdbg.h> 4 #include <malloc.h> 5 #include <new.h> 6 #include <stdlib.h> 7 #include <winheap.h> 8 #include <rtcsup.h> 9 #include <internal.h> 10 11 // 兩個版本的 new 實作方式，失敗時都會拋出 bad_alloc 例外 12 void * operator new( size_t cb ) 13 { 14 void *res; 15 16 for (;;) { 17 18 // allocate memory block 19 res = _heap_alloc(cb); 20 21 // if successful allocation, return pointer to memory 22 23 if (res) 24 break; 25 26 // call installed new handler 27 if (!_callnewh(cb)) // 申請失敗，則拋出 bad_alloc 例外 28 break; 29 30 // new handler was successful -- try to allocate again 31 } 32 33 RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0)); 34 35 return res; 36 } 37 #else /* _SYSCRT */ 38 39 #include <cstdlib> 40 #include <new> 41 42 _C_LIB_DECL 43 int __cdecl _callnewh(size_t size) _THROW1(_STD bad_alloc); 44 _END_C_LIB_DECL 45 46 void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) 47 { // try to allocate size bytes 48 void *p; 49 while ((p = malloc(size)) == 0) 50 if (_callnewh(size) == 0) 51 { // report no memory 52 _THROW_NCEE(_XSTD bad_alloc, ); 53 } 54 55 return (p); 56 }原始碼分析 new.cpp
1 #include <cruntime.h> 2 #include <malloc.h> 3 #include <new.h> 4 #include <stdlib.h> 5 #include <winheap.h> 6 #include <rtcsup.h> 7 8 void *__CRTDECL operator new(size_t) /*_THROW1(std::bad_alloc)*/; 9 10 void * operator new[]( size_t cb ) 11 { 12 void *res = operator new(cb); 13 14 RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0)); 15 16 return res; 17 }原始碼分析 new2.cpp
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/51066.html
標籤：C++