cpp拾遗——异常
1. 简介
当程序某个函数出错，但处理错误的逻辑在另一个函数，则使用异常。
2. 异常格式
抛出异常
当发生异常时，使用 throw 抛出一个对象。对象是堆内存，所以可以跨函数访问。
void func() {
throw 表达式;
}
捕获异常
try {
需要保护的程序;
}
catch (类型 形参) {
处理异常的程序;
}
catch (...) {
当所有异常处理都不匹配，则使用通用处理程序;
}
3. 示例
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
const int ARG_ERR = 100;
void func1(int a) {
if (a == 0) {
throw ARG_ERR;
}
throw 0;
}
void func() {
try {
func1(1);
}
catch (int e) {
if (e == ARG_ERR) {
cout << "收到传参错误" << endl;
exit (1);
}
cout << "收到未知异常，没能力处理，向上传递" << endl;
throw;
}
catch (...) {
cout << "收到未知异常，没能力处理，向上传递" << endl;
throw;
}
}
int main()
{
try {
func();
}
catch (...) {
cout << "收到未知异常" << endl;
}
return 0;
}
4. 异常匹配是严格进行类型匹配
throw 'c';
catch (int a) { // 接不到
}
- 栈解旋
当异常抛出后，函数返回，函数的栈对象被析构 - 异常接口声明
在声明函数时，可以显示指定该函数只能抛出的异常。
void func() throw(int , char *, int *); // 只能抛出这3种类型的异常
void func2() throw(); // 不能抛出任何异常
void func3(); 可以抛出任何异常
- 异常和对象生命周期
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
class T {
public:
T() {
cout << "构造" << endl;
}
T (const T &t) {
cout << "拷贝构造" << endl;
}
~T () {
cout << "析构" << endl;
}
};
void func1(int a) {
throw T();
}
void func() {
try {
func1(0);
}
catch (T t) {
cout << "捕捉" << endl;
throw;
}
}
int main()
{
try {
func();
}
catch (T t) {
cout << "main 捕捉" << endl;
}
catch (...) {
cout << "收到未知异常" << endl;
}
return 0;
}
运行结果
构造 // 异常对象，异常对象基于堆内存
拷贝构造 // 构造捕获函数实参对象，基于栈内存
捕捉 // 执行捕获函数
析构 // 析构捕获函数实参
拷贝构造 // 构造main捕获函数实参对象，基于栈
main 捕捉
析构 // 析构捕获对象实参
析构 // 析构异常对象
若异常对象继续抛出，则不会被释放，会一直到异常不再抛出再析构
使用引用接异常对象
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
class T {
public:
T() {
cout << "构造" << endl;
}
T (const T &t) {
cout << "拷贝构造" << endl;
}
~T () {
cout << "析构" << endl;
}
};
void func1(int a) {
throw T();
}
void func() {
try {
func1(0);
}
catch (T &t) {
cout << "捕捉" << endl;
throw;
}
}
int main()
{
try {
func();
}
catch (T &t) {
cout << "main 捕捉" << endl;
}
catch (...) {
cout << "收到未知异常" << endl;
}
return 0;
}
运行结果
构造
捕捉
main 捕捉
析构
不能使用指针接异常对象，因为要保证异常对象是基于堆的，不好实现。
- 异常和多态
利用多态特性，可以实现捕获框架不变，处理各种异常
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
class T {
public:
virtual const char* info() = 0;
};
class mem_leak_c : public T {
public:
mem_leak_c() {
}
~mem_leak_c() {
}
const char * info() {
return "内存泄漏";
}
};
class float_c : public T {
public:
float_c() {
}
~float_c() {
}
const char *info() {
return "浮点数运算";
}
};
void func1(int a) {
if (a > 0) {
throw float_c();
}
else {
throw mem_leak_c();
}
}
void func() {
try {
func1(1);
}
catch (T &t) {
cout << "发生了 " << t.info() << " 异常" << endl;
throw;
}
}
int main()
{
try {
func();
}
catch (T &t) {
cout << "main 捕捉" << endl;
}
catch (...) {
cout << "收到未知异常" << endl;
}
return 0;
}
9. 标准库异常
示例：
#include "iostream"
using namespace std;
#include <stdexcept>
class Teacher
{
public:
Teacher(int age) //构造函数, 通过异常机制 处理错误
{
if (age > 100)
{
throw out_of_range("年龄太大");
}
this->age = age;
}
protected:
private:
int age;
};
void mainxx()
{
try
{
Teacher t1(102);
}
catch (out_of_range e)
{
cout << e.what() << endl;
}
exception e;
system("pause");
}
