一、程序错误
程序错误包含以下:
编译错误,即语法错误。程序就无法被生成运行代码。
运行时错误
- 不可预料的逻辑错误
- 可以预料的运行异常
例如:
动态分配空间时可能不会成功
打开文件可能会失败
除法运算时分母可能为0
整数相乘可能溢出
数组越界……
二、C语言处理程序错误的方法
(1)、返回值
double func()
{
int ret = func();
if (ret == -1)
{
}
else if(ret == -2)
{
}
else if (ret == -3)
{
}
}
(2)、errno
在linux系统调用和C函数中,函数调用出错会设置全局变量error的值,我们需要在程序中检查error是否等于-1,等于-1的话就要进行错误处理。
(3)、goto语句
局部跳转。示例:
int test()
{
char*p1 = (char*)malloc(3);
if (p1!=NULL)
{
}
else
{
goto POS1;
}
char*p2 = (char*)malloc(3);
if (p2!=NULL)
{
}
else
{
goto POS1;
}
POS1:
exit(1);
POS2:
free(p1);
exit(1);
}
(4)、setjmp、longjmp
长跳转。示例:
#include <stdio.h>
#include <setjmp.h>
jmp_buf buf;
double Divide(double a, double b)
{
if (b == 0.0)
{
longjmp(buf, 1);// 跳转到保存点,即保存的栈信息处设置返回值
}
else
return a / b;
}
int main(void)
{
int ret;
ret = setjmp(buf);//讲当前栈信息保存在buf中,保存成功返回0
if (ret == 0) // try
{
printf("division ...\n");
printf("%f\n", Divide(5.0, 0.0));
}
else if (ret == 1) // catch
{
printf("divisiong by zero\n");
}
return 0;
}
C语言的出错处理被认为是紧耦合的,函数的使用者必须在非常靠近函数调用的地方编写错误处理代码,这会使得其变得笨拙以及难以使用。
三、异常语法
try
{
//try语句块
}
catch(类型1 参数1)
{
//针对类型1的异常处理
}
catch (类型2 参数2)
{
//针对类型2的异常处理
}
…
catch (类型n 参数n)
{
//针对类型n的异常处理
}
四、异常抛出
- 可以抛出内置类型异常也可以抛出自定义类型异常
- throw抛出一个类对象会调用拷贝构造函数
五、异常捕获
- 一个异常处理器一般只捕捉一种类型的异常
- 异常处理器的参数类型和抛出异常的类型相同
- …表示可以捕获任何异常
示例:
#include <iostream>
#include <string>
using namespace std;
//自定义类型异常
class MyException
{
public:
MyException(const char* message)
: message_(message)
{
cout<<"MyException ..."<<endl;
}
MyException(const MyException& other) : message_(other.message_)
{
cout<<"Copy MyException ..."<<endl;
}
~MyException()
{
cout<<"~MyException"<<endl;
}
const char* what() const
{
return message_.c_str();
}
private:
string message_;
};
double Divide(double a, double b)
{
if (b == 0.0)
{
//MyException e("division by zero");//调用拷贝构造函数
//throw e;
throw MyException("division by zero");//和函数返回对象类似,不调用拷贝构造函数
//throw 1;
}
else
return a / b;
}
int main(void)
{
try
{
cout<<Divide(5.0, 0.0)<<endl;
}
catch (MyException& e)
{
cout<<e.what()<<endl;
}
//catch (int)
//{
// cout<<"int exception ..."<<endl;
//}
catch (double)
{
cout<<"double exception ..."<<endl;
}
catch (...)
{
cout<<"catch a exception ..."<<endl;
}
}
六、异常传播
try块可以嵌套,程序按顺序寻找匹配的异常处理器,抛出的异常将被第一个类型符合的异常处理器捕获。如果内层try块后面没找到合适的异常处理器,该异常向外传播,到外层try块后面的catch块中寻找没有被捕获的异常将调用terminate函数,terminate函数默认调用abort终止程序。可以使用set_terminate函数指定terminate函数将调用的函数。
示例:
#include <iostream>
using namespace std;
class MyException
{
public:
MyException(const char* message)
: message_(message)
{
cout<<"MyException ..."<<endl;
}
MyException(const MyException& other) : message_(other.message_)
{
cout<<"Copy MyException ..."<<endl;
}
~MyException()
{
cout<<"~MyException"<<endl;
}
const char* what() const
{
return message_.c_str();
}
private:
string message_;
};
void MyTerminate()
{
cout<<"MyTerminate ..."<<endl;
}
int main(void)
{
set_terminate(MyTerminate);
try
{
try
{
throw MyException("test exception");
}
catch (int)
{
cout<<"Inner ..."<<endl;
cout<<"catch a int exception"<<endl;
}
//catch (MyException& e)
//{
// cout<<"Inner ..."<<endl;
// cout<<e.what()<<endl;
// throw e;
//}
}
catch (int)
{
cout<<"Outer ..."<<endl;
cout<<"catch a int exception"<<endl;
}
catch (MyException& e)
{
cout<<"Outer ..."<<endl;
cout<<e.what()<<endl;
}
}
七、栈展开
沿着嵌套调用链接向上查找,直至为异常找到一个catch子句。这个过程称之为栈展开。
- 栈展开时局部对象调用析构函数
注意:
析构函数应该从不抛出异常
栈展开期间会执行析构函数,在执行析构函数的时候,已经引发的异常但还没处理,如果这个过程中析构函数又抛出新的异常,将会调用标准库的terminate函数。
- 异常与构造函数
构造函数中可以抛出异常。如果在构造函数函数中抛出异常,则可能该对象只是部分被构造。即使对象只是被部分构造,也要保证销毁已构造的成员。
示例:
#include <iostream>
#include <string>
using namespace std;
class MyException
{
public:
MyException(const char* message)
: message_(message)
{
cout<<"MyException ..."<<endl;
}
MyException(const MyException& other) : message_(other.message_)
{
cout<<"Copy MyException ..."<<endl;
}
~MyException()
{
cout<<"~MyException"<<endl;
}
const char* what() const
{
return message_.c_str();
}
private:
string message_;
};
class Test
{
public:
Test()
{
cout<<"Test ..."<<endl;
}
Test(const Test& other)
{
cout<<"Copy Test ..."<<endl;
}
~Test()
{
cout<<"~Test ..."<<endl;
}
};
class Obj
{
public:
Obj()
{
cout<<"Obj ..."<<endl;
}
Obj(const Obj& other)
{
cout<<"Copy Obj ..."<<endl;
}
~Obj()
{
cout<<"~Obj ..."<<endl;
}
};
class Test3
{
public:
Test3()
{
cout<<"Test3 ..."<<endl;
}
Test3(const Test3& other)
{
cout<<"Copy Test3 ..."<<endl;
}
~Test3()
{
cout<<"~Test3 ..."<<endl;
//throw 4;//在析构函数里抛出异常,会调用<span style="font-size: 14px;">terminate终止程序</span>
}
};
class Test2
{
public:
Test2()
{
obj_ = new Obj;
cout<<"Test2 ..."<<endl;
throw MyException("test exception2");
}
Test2(const Test2& other)
{
cout<<"Copy Test2 ..."<<endl;
}
~Test2()
{
delete obj_;
cout<<"~Test2 ..."<<endl;
}
private:
Obj* obj_;
};
int main(void)
{
try
{
Test3 t3;
throw MyException("Test exception3");
}
catch (MyException& e)
{
cout<<e.what()<<endl;
}
catch (int)
{
cout<<"catch a int exception"<<endl;
}
}
输出: