異常處理、動態記憶體申請在不同編譯器之間的表現差異

阿新 • • 發佈：2020-03-23

續上節內容 c++中的異常處理 ...

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 = 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 = 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 = 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

異常處理、動態記憶體申請在不同編譯器之間的表現差異

續上節內容 c++中的異常處理 ... 目錄　　1、在main() 函式中丟擲異常會發生什麼　　2、在解構函式中丟擲異常會發生什麼　　3、函式的異常規格說明　 4、動態記憶體申請結果的分析　 5、關於 new 關鍵字的新用

springmvc在處理請求過程中出現異常資訊交由異常處理器進行處理，自定義異常處理器可以實現一個系統的異常處理邏輯。為了區別不同的異常通常根據異常型別自定義異常類，這裡我們建立一個自定義系統異常，如果controller、service、dao丟擲此類異常說明是系統預期處理的異常資訊。

springmvc在處理請求過程中出現異常資訊交由異常處理器進行處理，自定義異常處理器可以實現一個系統的異常處理邏輯。 1.1 異常處理思路系統中異常包括兩類：預期異常和執行時異常RuntimeException，前者通過捕獲異常從而獲取異常資訊，後者主要通過規範程式碼開發、測試通過手段減少執

springmvc在處理請求過程中出現異常信息交由異常處理器進行處理，自定義異常處理器可以實現一個系統的異常處理邏輯。為了區別不同的異常通常根據異常類型自定義異常類，這裏我們創建一個自定義系統異常，如果controller、service、dao拋出此類異常說明是系統預期處理的異常信息。

ansi req -type this spring 進行 name ext code springmvc在處理請求過程中出現異常信息交由異常處理器進行處理，自定義異常處理器可以實現一個系統的異常處理邏輯。 1.1 異常處理思路系統中異常包括兩類：預期異常和運行時異常Ru

異常處理、動態記憶體申請在不同編譯器之間的表現差異

目錄

1、在main() 函式中丟擲異常會發生什麼

2、在解構函式中丟擲異常會發生什麼

3、函式的異常規格說明

4、動態記憶體申請結果的分析

5、關於 new 關鍵字的新用法

（1）nothrow 關鍵字

（2）通過 new 在指定的地址上建立物件

異常處理、動態記憶體申請在不同編譯器之間的表現差異

springcloud系列—Zuul—第5章-4: Spring Cloud Zuul 異常處理、禁用過濾器、動態載入

異常處理、拋出異常

Python之操作Excel、異常處理、網絡編程

Python開發基礎-Day23try異常處理、socket套接字基礎1

Python開發基礎----異常處理、socket套接字基礎1

Python基礎知識進階（五---2）----程序基本結構、簡單分支、異常處理、三大實例分析、基本循環結構、通用循環構造方法、死循環嵌套循環、布爾表達式

七天學會ASP.NET MVC (六)——線程問題、異常處理、自定義URL

10.異常處理、自定義異常、斷言

異常處理、網絡編程

異常處理、模塊包、時間模塊、subprocess（調用shell命令）

接口開發、異常處理、網絡編程

java基礎第十二章（異常處理、工具類、集合）

Spring MVC溫故而知新 – 參數綁定、轉發與重定向、異常處理、攔截器

前端（十二）—— JavaScript基礎操作：if語句、for循環、while循環、for...in、for...of、異常處理、函數、事件、JS選擇器、JS操作頁面樣式

Java中的異常處理、泛型！圖文講解

Java框架-SpringMVC統一異常處理、ssm框架整合

python學習第31天之異常處理、網路程式設計part1

異常處理、動態記憶體申請在不同編譯器之間的表現差異

目錄

1、在main() 函式中丟擲異常會發生什麼

2、在解構函式中丟擲異常會發生什麼

3、函式的異常規格說明

4、動態記憶體申請結果的分析

5、關於 new 關鍵字的新用法

（1）nothrow 關鍵字

（2）通過 new 在指定的地址上建立物件

相關推薦