C++异常处理机制是一个用来有效地处理运行错误的非常强大且灵活的工具，它提供了更多的弹性、安全性和稳固性，克服了传统方法所带来的问题.
异常的抛出和处理主要使用了以下三个关键字： try、 throw 、 catch 。
抛出异常即检测是否产生异常，在C++中，其采用throw语句来实现，如果检测到产生异常，则抛出异常。该语句的格式为：
throw 表达式;
如果在try语句块的程序段中（包括在其中调用的函数）发现了异常，且抛弃了该异常，则这个异常就可以被try语句块后的某个catch语句所捕获并处理，捕获和处理的条件是被抛弃的异常的类型与catch语句的异常类型相匹配。由于C++使用数据类型来区分不同的异常，因此在判断异常时，throw语句中的表达式的值就没有实际意义，而表达式的类型就特别重要。
try-catch语句形式如下 ：
01.try
02.{
03. 包含可能抛出异常的语句；
04.}
05.catch(类型名 [形参名]) // 捕获特定类型的异常
06.{
07.
08.}
09.catch(类型名 [形参名]) // 捕获特定类型的异常
10.{
11.
12.}
13.catch(...) // 三个点则表示捕获所有类型的异常
14.{
15.}
【范例1】处理除数为0的异常。该范例将上述除数为0的异常可以用try/catch语句来捕获异常，并使用throw语句来抛出异常，从而实现异常处理，实现代码如代码清单1-1所示。
// 代码清单1-1
01.#include<iostream.h> //包含头文件
02.#include<stdlib.h>
03.
04.double fuc(double x, double y) //定义函数
05.{
06. if(y==0)
07. {
08. throw y; //除数为0，抛出异常
09. }
10. return x/y; //否则返回两个数的商
11.}
12.
13.void main()
14.{
15. double res;
16. try //定义异常
17. {
18. res=fuc(2,3);
19. cout<<"The result of x/y is : "<<res<<endl;
20. res=fuc(4,0); 出现异常，函数内部会抛出异常
21. }
22. catch(double) //捕获并处理异常
23. {
24. cerr<<"error of dividing zero.\n";
25. exit(1); //异常退出程序
26. }
27.}
【范例2】自定义异常类型
// 代码清单1-2
01.#include "stdafx.h"
02.#include<stdlib.h>
03.#include<crtdbg.h>
04.#include <iostream>
05.// 内存泄露检测机制
06.#define _CRTDBG_MAP_ALLOC
07.#ifdef _DEBUG
08.#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
09.#endif
10.
11.// 自定义异常类
12.class MyExcepction
13.{
14.public:
15.
16. // 构造函数,参数为错误代码
17. MyExcepction(int errorId)
18. {
19. // 输出构造函数被调用信息
20. std::cout << "MyExcepction is called" << std::endl;
21. m_errorId = errorId;
22. }
23.
24. // 拷贝构造函数
25. MyExcepction( MyExcepction& myExp)
26. {
27. // 输出拷贝构造函数被调用信息
28. std::cout << "copy construct is called" << std::endl;
29. this->m_errorId = myExp.m_errorId;
30. }
31.
32. ~MyExcepction()
33. {
34. // 输出析构函数被调用信息
35. std::cout << "~MyExcepction is called" << std::endl;
36. }
37.
38. // 获取错误码
39. int getErrorId()
40. {
41. return m_errorId;
42. }
43.
44.private:
45. // 错误码
46. int m_errorId;
47.};
48.
49.int main(int argc, char* argv[])
50.{
51. // 内存泄露检测机制
52. _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
53.
54. // 可以改变错误码,以便抛出不同的异常进行测试
55. int throwErrorCode = 110;
56.
57. std::cout << " input test code :" << std::endl;
58. std::cin >> throwErrorCode;
59.
60. try
61. {
62. if ( throwErrorCode == 110)
63. {
64. MyExcepction myStru(110);
65.
66. // 抛出对象的地址 -> 由catch( MyExcepction* pMyExcepction) 捕获
67. // 这里该对象的地址抛出给catch语句,不会调用对象的拷贝构造函数
68. // 传地址是提倡的做法,不会频繁地调用该对象的构造函数或拷贝构造函数
69. // catch语句执行结束后,myStru会被析构掉
70. throw &myStru;
71. }
72. else if ( throwErrorCode == 119 )
73. {
74. MyExcepction myStru(119);
75.
76. // 抛出对象,这里会通过拷贝构造函数创建一个临时的对象传出给catch
77. // 由catch( MyExcepction myExcepction) 捕获
78. // 在catch语句中会再次调用通过拷贝构造函数创建临时对象复制这里传过去的对象
79. // throw结束后myStru会被析构掉
80. throw myStru;
81. }
82. else if ( throwErrorCode == 120 )
83. {
84. // 不提倡这样的抛出方法
85. // 这样做的话,如果catch( MyExcepction* pMyExcepction)中不执行delete操作则会发生内存泄露
86.
87. // 由catch( MyExcepction* pMyExcepction) 捕获
88. MyExcepction * pMyStru = new MyExcepction(120);
89. throw pMyStru;
90. }
91. else
92. {
93. // 直接创建新对象抛出
94. // 相当于创建了临时的对象传递给了catch语句
95. // 由catch接收时通过拷贝构造函数再次创建临时对象接收传递过去的对象
96. // throw结束后两次创建的临时对象会被析构掉
97. throw MyExcepction(throwErrorCode);
98. }
99. }
100. catch( MyExcepction* pMyExcepction)
101. {
102. // 输出本语句被执行信息
103. std::cout << "执行了 catch( MyExcepction* pMyExcepction) " << std::endl;
104.
105. // 输出错误信息
106. std::cout << "error Code : " << pMyExcepction->getErrorId()<< std::endl;
107.
108. // 异常抛出的新对象并非创建在函数栈上，而是创建在专用的异常栈上,不需要进行delete
109. //delete pMyExcepction;
110. }
111. catch ( MyExcepction myExcepction)
112. {
113. // 输出本语句被执行信息
114. std::cout << "执行了 catch ( MyExcepction myExcepction) " << std::endl;
115.
116. // 输出错误信息
117. std::cout << "error Code : " << myExcepction.getErrorId()<< std::endl;
118. }
119. catch(...)
120. {
121. // 输出本语句被执行信息
122. std::cout << "执行了 catch(...) " << std::endl;
123.
124. // 处理不了,重新抛出给上级
125. throw ;
126. }
127.
128. // 暂停
129. int temp;
130. std::cin >> temp;
131.
132. return 0;
133.}
相关c++异常处理机制