C++异常
1 异常的基本概念
Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。也就是《C++ primer》中说的：将问题检测和问题处理相分离。
一种思想：在所有支持异常处理的编程语言中（例如java），要认识到的一个思想：在异常处理过程中，由问题检测代码可以抛出一个对象给问题处理代码，通过这个对象的类型和内容，实际上完成了两个部分的通信，通信的内容是“出现了什么错误”。当然，各种语言对异常的具体实现有着或多或少的区别，但是这个通信的思想是不变的。
一句话：异常处理就是处理程序中的错误。所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在,空指针，内存不足等等）。
2 比较C语言中处理异常的方法
在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。
这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。
还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。
c++异常机制相比C语言异常处理的优势?
- 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。
- 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。
- 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
- 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。
// 当a为-100，b为100时，a/b的结果为-1
// 因此返回值为-1时，无法判断是结果为-1,还是除0的错误.
int myDivide(int a, int b)
{
if (b == 0) return -1;
return a/b;
}
3 异常的语法
3.1 异常的基本语法
- C++异常的处理关键字
try throw catch - 可能出现异常的代码 放到 try块
- 利用throw抛出异常
- 利用catch捕获异常
- catch( 类型) 如果想捕获其他类型 catch(…)
- 如果捕获到的异常不想处理，而继续向上抛出，利用 throw
- 异常必须有函数进行处理，如果都不去处理，程序自动调用 terminate函数，中断掉
- 异常可以是自定义数据类型
/*
1. C++异常的处理关键字
try throw catch
2. 可能出现异常的代码 放到 try块
3. 利用throw抛出异常
4. 利用catch捕获异常
5. catch( 类型) 如果想捕获其他类型 catch(…)
6. 如果捕获到的异常不想处理，而继续向上抛出，利用 throw
*/
#include <iostream>
using namespace std;
void func1(int a)
{
if (a == 0)
{
cout << "func1函数抛出int类型异常" << endl;
throw 0; // 抛出int类型的异常
// throw 3.14; // 抛出double类型异常
// thorw 'c'; // 抛出char类型异常
// thorw "abcd"; // 抛出char*类型异常
}
}
void func2()
{
int a = 0;
try
{
func1(a);
}
catch(int)
{
cout << "func2捕获int类型的异常，但不处理，继续向上抛出" << endl;
throw; // 继续向上抛出捕获的异常
}
}
int main()
{
try
{
func2();
}
catch(int)
{
cout << "处理捕获的int类型异常" << endl;
}
catch(...) // catch(...)捕获其他所有类型异常(此处为捕获除了int类型异常的所有异常)
{
}
return 0;
}
// 8. 异常可以是自定义数据类型
#include <iostream>
using namespace std;
class myException
{
};
void func()
{
throw myException();
}
int main()
{
try
{
func();
}
catch(myException &e)
{
cout << "捕获并处理myException类型异常" << endl;
}
return 0;
}
3.2 异常严格类型匹配
异常机制和函数机制互不干涉,但是捕捉方式是通过严格类型匹配。
void TestFunction(){
cout << "开始抛出异常..." << endl;
//throw 10; //抛出int类型异常
//throw 'a'; //抛出char类型异常
//throw "abcd"; //抛出char*类型异常
string ex = "string exception!";
throw ex;
}
int main()
{
try{
TestFunction();
}
catch (int){
cout << "抛出Int类型异常!" << endl;
}
catch (char){
cout << "抛出Char类型异常!" << endl;
}
catch (char*){
cout << "抛出Char*类型异常!" << endl;
}
catch (string){
cout << "抛出string类型异常!" << endl;
}
//捕获所有异常
catch (...){
cout << "抛出其他类型异常!" << endl;
}
return 0;
}
3.3 栈解旋(unwinding)
异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构(析构的顺序与构造的顺序相反)。这一过程称为栈的解旋(unwinding).
class Person{
public:
Person(string name){
mName = name;
cout << mName << "对象被创建!" << endl;
}
~Person(){
cout << mName << "对象被析构!" << endl;
}
public:
string mName;
};
void TestFunction()
{
Person p1("aaa");
Person p2("bbb");
Person p3("ccc");
throw 10; //抛出异常
}
int main()
{
try{
TestFunction();
}
catch (...){
cout << "异常被捕获!" << endl;
}
return 0;
}
3.4 异常的接口声明
- 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。void func() throw(int,double) // 只允许抛出int和double类型异常
- 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()
- 一个不抛任何类型异常的函数可声明为:void func() throw(); // throw(空)代表不允许抛出异常
- 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。
//可抛出所有类型异常
void TestFunction01()
{
throw 10;
}
//只能抛出int char char*类型异常
void TestFunction02() throw(int,char,char*)
{
string exception = "error!";
throw exception;
}
//不能抛出任何类型异常
void TestFunction03() throw()
{
throw 10;
}
int main(){
try{
TestFunction01();
//TestFunction02();
//TestFunction03();
}
catch (...){
cout << "捕获异常!" << endl;
}
return 0;
}
3.5 异常变量的生命周期
- 抛出的是 throw MyException(); catch (MyException e) 调用拷贝构造函数 效率低，对象会在catch语句块结束后释放
- 抛出的是 throw MyException(); catch (MyException &e) 只调用默认构造函数，效率高，对象会在catch语句块结束后释放 推荐
- 抛出的是 new MyException(); catch (MyException *e) 只调用默认构造函数，自己要管理释放
#include <iostream>
using namespace std;
class myException
{
public:
myException()
{
cout << "myException默认构造函数" << endl;
}
myException(const myException& e)
{
cout << "myException拷贝构造函数" << endl;
}
~myException()
{
cout << "myException析构函数" << endl;
}
};
void doWork()
{
//throw myException(); // 对象会在catch语句块结束后释放,会调用拷贝构造函数
throw myException(); // 对象会在catch语句块结束后释放,只调用默认构造函数
//throw new myException(); // 只调用默认构造函数 自己要管理释放
}
int main()
{
try
{
doWork();
}
//catch(myException e)
catch(myException &e)
//catch(myException *e)
{
cout << "catch语句块" << endl;
}
return 0;
}
3.6 异常的多态使用
#include <iostream>
using namespace std;
class BaseMyException
{
public:
virtual void print() = 0;
};
class ChildMyException : public BaseMyException
{
public:
virtual void print() // 重写
{
cout << "ChildMyException" << endl;
}
};
void doWork()
{
throw ChildMyException();
}
int main()
{
try
{
doWork(); // 抛出子类对象
}
catch(BaseMyException &e) // 用父类引用接收子类对象---多态的使用
{
cout << "catch语句块" << endl;
}
return 0;
}
4 C++标准异常库
4.1 标准库介绍
标准库中也提供了很多的异常类，它们是通过类继承组织起来的。异常类继承层级结构图如下：
每个类所在的头文件在图下方标识出来。
标准异常类的成员：
- 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
- logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述
- 所有的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。
标准异常类的具体描述：
| 异常名称 | 描述 |
|---|---|
| exception | 所有标准异常类的父类 |
| bad_alloc | 当operator new and operator new[]，请求分配内存失败时 |
| bad_exception | 这是个特殊的异常，如果函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常抛出列表中没有的异常，这是调用的unexpected函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型 |
| bad_typeid | 使用typeid操作符，操作一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常 |
| bad_cast | 使用dynamic_cast转换引用失败的时候 |
| ios_base::failure | io操作过程出现错误 |
| logic_error | 逻辑错误，可以在运行前检测的错误 |
| runtime_error | 运行时错误，仅在运行时才可以检测的错误 |
logic_error的子类：
| 异常名称 | 描述 |
|---|---|
| length_error | 试图生成一个超出该类型最大长度的对象时，例如vector的resize操作 |
| domain_error | 参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操作非负数的函数 |
| out_of_range | 超出有效范围 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常 |
runtime_error的子类：
| 异常名称 | 描述 |
|---|---|
| range_error | 计算结果超出了有意义的值域范围 |
| overflow_error | 算术计算上溢 |
| underflow_error | 算术计算下溢 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常 |
#include <iostream>
#include <stdexcept>
using namespace std;
class Person
{
public:
Person(int age)
{
if (age < 0 || age > 150)
{
// 抛出out_of_range异常,并写入错误信息以供what函数调用打印
throw out_of_range("年龄应该在0-150岁之间!");
}
}
public:
int mAge;
};
int main()
{
try
{
Person p(151);
}
//catch (exception& ex) 父类引用接收
catch (out_of_range& ex) // 捕获out_of_range异常
{
cout << ex.what() << endl; // 调用异常类中的what函数，打印信息
}
return 0;
}
4.2 编写自己的异常类
① 标准库中的异常是有限的；
② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。
如何编写自己的异常类？
- 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。
- 当继承标准异常类时，应该重载父类的what函数和虚析构函数。
- 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。
#include <iostream>
#include <stdexcept>
using namespace std;
//自定义异常类
class MyOutOfRange:public exception // 继承父类
{
public:
MyOutOfRange(const string errorInfo)
{
this->m_Error = errorInfo;
}
MyOutOfRange(const char * errorInfo)
{
this->m_Error = string( errorInfo);
}
virtual ~MyOutOfRange()
{
}
// 重写what函数
virtual const char *what() const _GLIBCXX_USE_NOEXCEPT
{
return this->m_Error.c_str() ;
}
private:
string m_Error;
};
class Person
{
public:
Person(int age)
{
if (age <= 0 || age > 150)
{
throw MyOutOfRange(("我的异常 年龄必须在0~150之间"));
}
else
{
this->m_Age = age;
}
}
int m_Age;
};
int main()
{
try
{
Person p(151);
}
catch (MyOutOfRange &e) // 捕获自己编写的异常类
{
cout << e.what() << endl;
}
}
扫一扫
1585
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
