1. C++中的异常处理
（1）catch语句块可以抛出异常
①catch中获捕的异常可以被重新抛出
②抛出的异常需要外层的try-catch块来捕获
③catch(…)块中抛异常的方法是throw;也是将所有异常重新抛出
（2）catch块中重新抛异常的意义
①可以被外层try-catch块捕获，并重新解释异常的信息。
②工程开发中使用这样的方式统一异常类型
A.假设我们的私有库使用到了第3方的库函数，如func。
B.但其抛出的异常类型为int*类型，很不友好。我们可以在私有库使用func的地方捕获这个异常，并在catch块中重新解释这个异常并抛出为我们自定义的Exception类型.
【编程实验】异常的重新解释
#include <iostream>
using namespace std;
//演示在catch块中可以抛出异常
void Demo()
{
try
{
try
{
throw 'c';
}
catch(int i)
{
cout << "Inner:catch(int i)" << endl;
throw i; //重新抛出异常
}
catch(...)
{
cout << "Inner:catch(...)" << endl;
throw; //抛出所有类型的异常
}
}catch(...)
{
cout << "Outer:catch(...)" << endl;
}
}
/*
假设：当前的函数是第三方库中的函数。因此，我们无法修改源代码
函数名： void func(int i)
抛出异常的类型：int
-1 ==> 参数异常
-2 ==> 运行异常
-3 ==> 超时异常
*/
void func(int i)
{
)
{
;
}
)
{
;
}
)
{
;
}
//正常运时时
cout << "Call func(int i)" << endl;
}
//以下是我们的私有库，当中使用到了第3方的库，这里需要将第3方库的
//异常类型统一成我们的异常信息格式
void MyFunc( int i)
{
try
{
func(i);
}
catch(int i)
{
switch(i)
{
:
throw "Invalid Parameter";
break;
:
throw "Runtime Exception";
break;
:
throw "Timeout Exception";
break;
}
}
}
int main()
{
Demo();
cout << endl;
try
{
MyFunc();
}
catch(const char* cs)
{
cout << "Exception info: " << cs << endl;
}
;
};
/*输出结果：
Inner:catch(...)
Outer:catch(...)
Exception info: Timeout Exception
*/
2. 自定义异常类类型
（1）对于类类型异常的匹配依旧是至上而下严格匹配
（2）赋值兼容性原则在异常匹配中依然适用，因此一般而言：
①匹配子类异常的catch放在上部
②匹配父类异常的catch放在下部（否则如果放上面，则子类异常由于赋值兼容会被父类捕获）。
（3）工程中会定义一系列的异常类，每个类代表可能出现的一种异常类型。
（4）代码复用时可能需要重解释不同的异常类（如由于继承的层次关系，很可能父类的异常类在子类中会被重新解释）
（5）在定义catch语句块时推荐使用引用作为参数
【编程实验】类类型的异常
#include <iostream>
#include <string>
using namespace std;
class Base
{
};
class Exception: public Base
{
int m_id;
string m_desc;
public:
Exception(int id, string desc)
{
m_id = id;
m_desc = desc;
}
int id() const //考虑const Exception对象时，函数加const
{
return m_id;
}
string description() const
{
return m_desc;
}
};
/*
假设：当前的函数是第三方库中的函数。因此，我们无法修改源代码
函数名： void func(int i)
抛出异常的类型：int
-1 ==> 参数异常
-2 ==> 运行异常
-3 ==> 超时异常
*/
void func(int i)
{
)
{
;
}
)
{
;
}
)
{
;
}
//正常运时时
cout << "Call func(int i)" << endl;
}
//以下是我们的私有库，当中使用到了第3方的库，这里需要将第3方库的
//异常类型统一成我们的异常信息格式
void MyFunc( int i)
{
try
{
func(i);
}
catch(int i)
{
switch(i)
{
:
, "Invalid Parameter");
break;
:
, "Runtime Exception");
break;
:
, "Timeout Exception");
break;
}
}
}
int main()
{
try
{
MyFunc();
}
catch(const Exception& e) //注意使用引用以防止拷贝
{
cout << "Exception info: " << endl;
cout << " ID: " << e.id() << endl;
cout << " Description: " << e.description() << endl;
}
catch(const Base& e) //父类异常放下部
{
cout << "catch(const Base& e)" << endl;
}
;
};
/*输出结果：
Exception info:
ID: -3
Description: Timeout Exception
*/
3.C++标准库中提供的异常类族
（1）标准库(#include <stdexcept>)中的异常都是从exception类派生的
（2）exception类有两个主要的分支
①logic_error：常用于程序中的可避免的逻辑错误
②runtime_error：常用于程序中无法避免的恶性错误
（3）标准库中的异常
【编程实验】标准库中的异常使用
//Array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_
#include <stdexcept> //引入异常类
using namespace std;
template <typename T, int N>
class Array
{
T m_array[N];
public:
int length() const;
bool set(int index, T value);
bool get(int index, T& value);
T& operator[](int index);
T operator[](int index) const;
virtual ~Array();
};
template < typename T, int N>
int Array<T, N>::length() const
{
return N;
}
template < typename T, int N>
bool Array<T, N>::set(int index, T value)
{
<= index) && (index < N);
if (ret)
{
m_array[index] = value;
}
return ret;
}
template < typename T, int N>
bool Array<T, N>::get(int index, T& value)
{
<= index) && (index < N);
if (ret)
{
value = m_array[index];
}
return ret;
}
template < typename T, int N>
T& Array<T, N>::operator[](int index)
{
<= index) && (index < N))
{
return m_array[index];
}
else
{
//out_of_range是标准库中的异常类
throw out_of_range("T& Array<T, N>::operator[](int index)");
}
}
template < typename T, int N>
T Array<T, N>::operator[](int index) const
{
<= index) && (index < N))
{
return m_array[index];
}
else
{
//out_of_range是标准库中的异常类
throw out_of_range("T Array<T, N>::operator[](int index) const");
}
}
template < typename T, int N>
Array<T, N>::~Array()
{
}
#endif
//HeapArray.h
#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_
#include <stdexcept> //引入异常类
using namespace std;
template < typename T>
class HeapArray
{
private:
int m_length;
T* m_pointer;
HeapArray(int len);
HeapArray(const HeapArray<T>& obj);
bool construct();
public:
static HeapArray<T>* NewInstance(int length);
static void ReleaseInstance(const HeapArray<T>* pointer);
int length() const;
bool get(int index, T& value);
bool set(int index, T value);
T& operator[](int index);
T operator[](int index) const; //与上面函数构成重载关系
HeapArray<T>& self() const;
HeapArray<T>& self(); //与上面函数构成重载关系
~HeapArray();
};
template <typename T>
HeapArray<T>::HeapArray(int len)
{
m_length = len;
}
template <typename T>
HeapArray<T>::HeapArray(const HeapArray<T>& obj)
{
m_pointer = obj.m_pointer;
m_length = obj.m_length;
}
template <typename T>
bool HeapArray<T>::construct()
{
m_pointer = new T[m_length];
return m_pointer != NULL;
}
template <typename T>
HeapArray<T>* HeapArray<T>::NewInstance(int len)
{
HeapArray<T>* ret = new HeapArray<T>(len);
if (!(ret && ret->construct()))
{
delete ret;
ret = ;
}
return ret;
}
template <typename T>
void HeapArray<T>::ReleaseInstance(const HeapArray<T>* pointer)
{
delete pointer;
}
template <typename T>
int HeapArray<T>::length() const
{
return m_length;
}
template <typename T>
bool HeapArray<T>::get(int index, T& value)
{
<= index)&&(index < m_length));
if(ret)
{
value = m_pointer[index];
}
return ret;
}
template <typename T>
bool HeapArray<T>::set(int index, T value)
{
<= index)&&(index < m_length));
if(ret)
{
m_pointer[index] = value ;
}
return ret;
}
template <typename T>
T& HeapArray<T>::operator[](int index)
{
<= index)&&(index < m_length))
{
return m_pointer[index];
}
else
{
throw out_of_range("T& HeapArray<T>::operator[](int index)");
}
}
template <typename T>
T HeapArray<T>::operator[](int index) const
{
<= index)&&(index < m_length))
{
return m_pointer[index];
}
else
{
throw out_of_range("T HeapArray<T>::operator[](int index) const");
}
}
template <typename T>
HeapArray<T>& HeapArray<T>::self() const
{
return *this;
}
template <typename T>
HeapArray<T>& HeapArray<T>::self()
{
return *this;
}
template <typename T>
HeapArray<T>::~HeapArray()
{
delete[] m_pointer;
}
#endif
//test.cpp
#include <iostream>
#include <string>
#include <memory> //for auto_ptr
#include "Array.h"
#include "HeapArray.h"
using namespace std;
void TestArray()
{
Array<> a;
; i<a.length(); i++)
{
a[i] = i;
}
; i<; i++)
{
cout << a[i] << endl;
}
}
void TestHeapArray()
{
//使用智能指针，目的是自动释放堆空间
auto_ptr< HeapArray<));
if(pa.get() != NULL)
{
HeapArray<double>& array = pa->self();
; i<array.length(); i++)
{
array[i] = i;
}
; i<; i++)
{
cout << array[i] << endl;
}
}
}
int main()
{ //试验1：观察异常出错的信息
TestArray();
cout << endl;
TestHeapArray();
//试验2： 观察异常出错的信息
// try
// {
// TestArray();
// cout << endl;
// TestHeapArray();
// }
// catch(...)
// {
// cout << "Exception" << endl;
// }
;
};
4. C++异常机制中没提供finally块解决方案
（1）RAII技术(Resource Aquisition Is Initialization，资源获得即初始化)
①基本的思路：通过一个局部对象来表现资源，于是局部对象的析构函数将会释放资源。即，将资源封装成一个类，将资源的初始化封装在构造函数里，释放封装在析构函数里。要使用资源的时候，就实例化一个局部对象。
②在抛出异常的时候，由于局部对象脱离了作用域，自动调用析构函数，会保证资源被释放。
（2）具体做法
①直接使用局部变量。
try{
File f("xxx.ttt"); //使用局部对象
//其他操作
} //异常发生时和正常情况下，文件资源都在这里被释放
catch {
//...
}
②将资源封装在一个类中
class Test{
public:
File *file;//资源被封装起来
Test() { file = new file(...); }
~Test() { delete file;}
};
try{
Test t; //使用局部对象
//其他操作
} //无论什么情况下,t在这里被释放，同时调用析构函数
catch {
//...
}
③使用智能指针
try
{
std::auto_ptr<file> pfile = new file();
//....
} //无论什么情况，智能指针都在这里被释放
catch(...)
{
//....
}
5. 构造函数中抛出异常的问题
①问题：构造未完成，析构函数将不被调用，可能造成内存泄漏。因此，一般不建议在构造函数中抛出异常
【编程实验】构造函数中抛异常
#include <iostream>
using namespace std;
class Test
{
private:
int* p;
public:
Test()
{
cout<< "Test()" << endl;
p= ];
; //抛出异常，构造函数非正常结束
}
~Test()
{
cout <<"~Test()" << endl; delete[] p;
}
};
int main()
{
try
{
Test t; //t未完成构造就出异常，就跳到catch语句去，
//注意t的作用域为try的{}，因没被执行完，所以
//还没调用析构函数就跳到catch作用域中—内存泄漏
}
catch (int e)
{
cout <<"Catch:"<<e << endl;
}
;
}
/*输出结果
Test()
Catch:10
*/
②解决方案：
【方案1】在构造函数中捕获异常、做善后处理后重新抛出异常
#include <iostream>
using namespace std;
class Test
{
private:
int* p1;
int* p2;
public:
Test()
{
;
cout<< "Test()" << endl;
try
{
nStep = ;
p1 = ];
if( p1 == NULL)
{
//delete[] p1;
throw nStep; //制造异常
}
nStep = ;
p2 = ];
if( p2 == NULL )
{
//delete p2;
throw nStep; //制造异常
}
}
catch(int n)
{
//构造函数中发生异常时，析构函数不会被调用，所以
//要自己做善后处理！
)
delete[] p1; //第1步出错时，销毁p1堆空间
)
delete[] p2;//第2步出错时，销毁p2\p1堆空间
throw n; //继续抛出，通知调用者构造函数调用失败
}
}
~Test()
{
cout <<"~Test()" << endl;
delete[] p1;
delete[] p2;
}
};
int main()
{
try
{
Test t; //Test的构造函数中可能发生异常
}
catch (int e)
{
cout <<"Catch:"<<e << endl;
}
;
}
【方案2】 二阶构造法（可参考《第27课 二阶构造模式》）
6. 小结
（1）catch语句块中可以抛出异常
（2）异常的类型可以是自定义类类型
（3）赋值兼容性原则在异常匹配中依然适用
（4）标准库中的异常都是从exception类派生的。