本文介绍: c++异常处理使得异常的引发和异常的处理不必在一个函数中,这样底层函数可 以着重解决具体问题,而不必过多的考虑异常的处理。),要认识到的一个思想: 在异常处理过程中,由问题检测代码可以抛出一个对象给问题处理代码,通过这个 对象类型内容,实际上完成了两个部分的通信,通信的内容是“还有一个缺点就是函数返回值只有一个,你通过函数返回值表示错误代码, 那么函数就不能返回其他的值。转换是非常有用的,但是它也会带来一些问题,比如在转换指针时,我们很可能将其转换一个比它更大的类型,但这可能会破坏其他的数据

C++类型转换

        类型转换(cast)
是将一种数据类型转换成另一种数据类型。例如,如果将一个整型 值赋给一个浮点类型变量编译器会暗地里将其转换成浮点类型
        转换是非常有用的,但是它也会带来一些问题,比如在转换指针时,我们很可能将其转换成一个比它更大的类型,但这可能会破坏其他的数据
        应该小心类型转换,因为转换也就相当于对编译器说:忘记类型检查,把它看做其 他的类型
        一般情况下,尽量少的去使用类型转换,除非用来解决非常特殊的问题。
        无论什么原因,任何一个程序如果使用很多类型转换都值得怀疑.
        标准 c++
提供了一个显示的转换语法,来替代旧的
C
风格类型转换
        使用 C
风格强制转换可以把想要的任何东西转换成我们需要类型。那为什么 还需要一个新的 C++
类型强制转换呢?
        新类型强制转换可以提供更好控制强制转换过程,允许控制各种不同种类的强 制转换。C++
风格的强制转换其他的好处是,它们能更清晰的表明它们要干什么。
        程序员只要扫一眼这样的代码,就能立即知道一个强制转换的目的。

静态转换(static_cast)

        用于层次结构基类父类)和派生类子类)之间指针引用的转换。
        进行上行转换(把派生类指针引用转换成基类表示)是安全的;
        进行下行转换(把基类指针引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
        用于基本数据类型之间的转换,如把 int
转换成
char
,把
char
转换成
int
。这种转 换的安全性也要开发人员来保证
class Animal{};
class Dog : public Animal{};
class Other{};
//基础数据类型转换
void test01(){
    char a = 'a';
    double b = static_cast<double>(a);
}
//继承关系指针互相转换
void test02(){
    //继承关系指针转换
    Animal* animal01 = NULL;
    Dog* dog01 = NULL;
    //子类指针转成父类指针,安全
    Animal* animal02 = static_cast<Animal*&gt;(dog01);
    //父类指针转成子类指针,不安全
    Dog* dog02 = static_cast<Dog*>(animal01);
}
//继承关系引用相互转换
void test03(){
    Animal ani_ref;
    Dog dog_ref;
    //继承关系指针转换
    Animal&amp; animal01 = ani_ref;
    Dog&amp; dog01 = dog_ref;
    //子类指针转成父类指针,安全
    Animal&amp; animal02 = static_cast<Animal&amp;>(dog01);
    //父类指针转成子类指针,不安全
    Dog&amp; dog02 = static_cast<Dog&amp;>(animal01);
}
//无继承关系指针转换
void test04(){
    Animal* animal01 = NULL;
    Other* other01 = NULL;
    //转换失败
    //Animal* animal02 = static_cast<Animal*>(other01);
}

动态转换(dynamic_cast)

        dynamiccast
主要用于类层次间的上行转换和下行转换;
        在类层次间进行上行转换时,dynamic
cast

static
cast
效果是一样的;
        在进行下行转换时,dynamic
cast
具有类型检查功能,比
static_cast
更安全;
class Animal {
public:
    virtual void ShowName() = 0;
};
class Dog : public Animal{
    virtual void ShowName(){
        cout << "I am a dog!" << endl;
    }
};
class Other {
public:
    void PrintSomething(){
        cout << "我是其他类!" << endl;
    }
};
//普通类型转换
void test01(){
    //不支持基础数据类型
    int a = 10;
    //double a = dynamic_cast<double>(a);
}
//继承关系指针
void test02(){
    Animal* animal01 = NULL;
    Dog* dog01 = new Dog;
    //子类指针转换成父类指针 可以
    Animal* animal02 = dynamic_cast<Animal*>(dog01);
    animal02->ShowName();
    //父类指针转换成子类指针 不可以
    //Dog* dog02 = dynamic_cast<Dog*>(animal01);
}
//继承关系引用
void test03(){
    Dog dog_ref;
    Dog&amp; dog01 = dog_ref;
    //子类引用转换成父类引用 可以
    Animal&amp; animal02 = dynamic_cast<Animal&amp;>(dog01);
    animal02.ShowName();
}
//无继承关系指针转换
void test04(){
    Animal* animal01 = NULL;
    Other* other = NULL;
    //不可以
    //Animal* animal02 = dynamic_cast<Animal*>(other);
}

常量转换(const_cast)

        该运算符用来修改类型的 const
属性。。
        常量指针被转化成非常量指针,并且仍然指向原来的对象
        常量引用被转换成非常量引用,并且仍然指向原来的对象
        注意:
不能直接对非指针和非引用的变量使用
const_cast
操作符去直接移除它的 const.
//常量指针转换成非常量指针
void test01(){
    const int* p = NULL;
    int* np = const_cast<int*>(p);
    int* pp = NULL;
    const int* npp = const_cast<const int*>(pp);
    const int a = 10; //不能对非指针或非引用进行转换
    //int b = const_cast<int>(a); }
    //常量引用转换成非常量引用
void test02(){
    int num = 10;
    int &amp; refNum = num;
    const int&amp; refNum2 = const_cast<const int&amp;>(refNum);
}

重新解释转换(reinterpret_cast)

        这是最不安全的一种转换机制,最有可能出问题。
        主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成 一个整数,也可以将一个整数转换成一个指针.

C++异常

异常基本概念

        Bjarne Stroustrup 说:提供异常的基本目的就是为了处理上面的问题。基本思想是: 让一个函数在发现了自己无法处理错误时抛出(throw
)一个异常,然后它的 (直接或者间接)调用者能够处理这个问题。也就是《C++ primer
》中说的:将问 题检测和问题处理相分离。
        一种思想:在所有支持异常处理的编程语言中(例如 java
),要认识到的一个思想: 在异常处理过程中,由问题检测代码可以抛出一个对象给问题处理代码,通过这个 对象的类型和内容,实际上完成了两个部分的通信,通信的内容是“
出现了什么错 误”
。当然,各种语言对异常的具体实现有着或多或少的区别,但是这个通信的思 想是不变的。
        一句话:异常处理就是处理程序中的错误。所谓错误是指在程序运行过程中发生 的一些异常事件(如:除 0
溢出,数组下标越界,所要读取文件不存在
,
空指针, 内存不足等等)。
        回顾一下:我们以前编写程序是如何处理异常?
        在 C
语言的世界中,对错误的处理总是围绕着两种方法:一是使用整型返回值 标识错误;二是使用 errno
宏(可以简单理解为一个全局整型变量)去记录错误。 当然 C++
中仍然是可以用这两种方法的。 这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回 1
表示成功, 返回 0
表示出错;而有些函数返回
0
表示成功,返回
0
表示出错。
        还有一个缺点就是函数的返回值只有一个,你通过函数的返回值表示错误代码, 那么函数就不能返回其他的值。当然,你也可以通过指针或者 C++
的引用来返回另 外的值,但是这样可能会令你的程序略微晦涩难懂。
        c++异常机制相比
C
语言异常处理的优势
?
        函数的返回值可以忽略,但异常不可忽略。如果程序出现异常,但是没有被捕获, 程序就会终止,这多少会促使程序员开发出来的程序更健壮一点。而如果使用 C 语言error
宏或者函数返回值,调用者都有可能忘记检查,从而没有对错误进行 处理,结果造成程序莫名其面的终止或出现错误的结果
        整型返回值没有任何语义信息。而异常却包含语义信息,有时你从类名就能够体 现出来。
        整型返回值缺乏相关的上下文信息。异常作为一个类,可以拥有自己的成员,这 些成员就可以传递足够的信息
        异常处理可以在调用跳级。这是一个代码编写时的问题:假设在有多个函数的调 用栈中出现了某个错误,使用整型返回码要求你在每一级函数中都要进行处理。而 使用异常处理的栈展开机制,只需要在一处进行处理就可以了,不需要每级函数都 处理。
//如果判断返回值,那么返回值是错误码还是结果?
//如果不判断返回值,那么 b==0 时候,程序结果已经不正确
//A 写的代码
int A_MyDivide(int a,int b){
    if (b == 0){
        return -1;
    }
    return a / b;
}
//B 写的代码
int B_MyDivide(int a,int b){
    int ba = a + 100;
    int bb = b;
    int ret = A_MyDivide(ba, bb); //由于 B 没有处理异常,导致 B 结果运算错误
    return ret;
}
//C 写的代码
int C_MyDivide(){
    int a = 10;
    int b = 0;
    int ret = B_MyDivide(a, b); //更严重的是,由于 B 没有继续抛出异常,导
    致 C 的代码没有办法捕获异常
    if (ret == -1){
        return -1;
    }
    else{
        return ret;
    }
}
//所以,我们希望:
//1.异常应该捕获,如果你捕获,可以,那么异常必须继续抛给上层函数,你不处理,不
代表你的上层不处理
//2.这个例子,异常没有捕获的结果就是运行结果错的一塌糊涂,结果未知,未知的结果
程序没有必要执行下去

异常语法

int A_MyDivide(int a, int b){
    if (b == 0){
        throw 0;
    }
    return a / b;
}
//B 写的代码 B 写代码比较粗心,忘记处理异常
int B_MyDivide(int a, int b){
    int ba = a;
    int bb = b;
    int ret = A_MyDivide(ba, bb) + 100; //由于 B 没有处理异常,导致 B 结果运算错误
    return ret;
}
//C 写的代码
int C_MyDivide(){
    int a = 10;
    int b = 0;
    int ret = 0;
    //没有处理异常,程序直接中断执行
    #if 1 
    ret = B_MyDivide(a, b);
    //处理异常
    #else
    try{
        ret = B_MyDivide(a, b); //更严重的是,由于 B 没有继续抛出异常,导致 C 的代码没有办法捕获异常
    }
    catch (int e){
        cout << "C_MyDivide Call B_MyDivide 除数为:" << e << endl;
    }
    #endif
    return ret;
}
int main(){
    C_MyDivide();
    system("pause");
    return EXIT_SUCCESS;
}
总结
:
        若有异常则通过 throw
操作创建一个异常对象并抛出。
        将可能抛出异常的程序段放到 try
块之中。
        如果在 try
段执行期间没有引起异常,那么跟在
try
后面的
catch
字句就不会执行。
        catch 子句会根据出现的先后顺序被检查,匹配
catch
语句捕获并处理异常
(
或继续抛出异常)
        如果匹配的处理未找到,则运行函数 terminate
自动调用,其缺省功能调用abort 终止程序。
        处理不了的异常,可以在 catch
最后一个分支,使用
throw
,向上抛。
        c++异常处理使得异常的引发和异常的处理不必在一个函数中,这样底层的函数可 以着重解决具体问题,而不必过多的考虑异常的处理。上层调用者可以在适当的位 置设计对不同类型异常的处理。

 异常严格类型匹配

        异常机制和函数机制互不干涉,
但是捕捉方式是通过严格类型匹配
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;
    }
    system("pause");
    return EXIT_SUCCESS;
}

栈解旋(unwinding)

异常被抛出后,从进入 try 块起,到异常被抛掷前,这期间在栈上构造的所有对象,
都会被自动析构。析构的顺序与构造的顺序相反,这一过程称为栈的解旋
(unwinding).
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;
    }
    system("pause");
    return EXIT_SUCCESS;
}

异常接口声明

        为了加强程序的可读性,可以在函数声明中列出可能抛出异常的所有类型,例如: void func() throw(A,B,C);这个函数
func
能够且只能抛出类型
A,B,C
及其子类型的异 常。
        如果在函数声明中没有包含异常接口声明,则此函数可以抛任何类型的异常,例

:void func()
        一个不抛任何类型异常的函数可声明为:void func() 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;
    }
    system("pause");
    return EXIT_SUCCESS;
}
请分别在
qt vs linux
下做测试
! Qt and Linux
正确
!

异常变量生命周期

        throw 的异常是有类型的,可以是数字字符串、类对象。
        throw 的异常是有类型的,
catch
严格匹配异常类型。
class MyException
{
public:
    MyException(){
        cout << "异常变量构造" << endl;
    }
    MyException(const MyException &amp; e)
    {
        cout << "拷贝构造" << endl;
    }
    ~MyException()
    {
        cout << "异常变量析构" << endl;
    }
};
void DoWork()
{
    throw new MyException(); //test1 2 都用 throw MyExecption();
}
void test01()
{
    try
    {
        DoWork();
    }
    catch (MyException e)
    {
        cout << "捕获 异常" << endl;
    }
}
void test02()
{
    try
    {
        DoWork();
    }
    catch (MyException &amp;e)
    {
        cout << "捕获 异常" << endl;
    }
}
void test03()
{
    try
    {
        DoWork();
    }
    catch (MyException *e)
    {
        cout << "捕获 异常" << endl;
        delete e;
    }
}

异常的多态使用

//异常基类
class BaseException{
public:
    virtual void printError(){};
};
//空指针异常
class NullPointerException : public BaseException{
public:
    virtual void printError(){
        cout << "空指针异常!" << endl;
    }
};
//越界异常
class OutOfRangeException : public BaseException{
public:
    virtual void printError(){
        cout << "越界异常!" << endl;
    }
};
void doWork(){
    throw NullPointerException();
}
void test()
{
    try{
        doWork();
    }
    catch (BaseException&amp; ex){
        ex.printError();
    }
}

C++标准异常库

标准库介绍

        标准库中也提供了很多的异常类,它们是通过类继承组织起来的。异常类继承层级结构图如下:
每个类所在的头文件在图下方标识出来。
标准异常类的成员
        ① 在上述继承体系中,每个类都有提供了构造函数复制构造函数、和赋值操作 符重载。
        ② logicerror
类及其子类、
runtime
error
类及其子类,它们的构造函数是接受一个 string 类型的形式参数用于异常信息描述
        ③ 所有的异常类都有一个
what()
方法,返回
const char*
类型(
C
风格字符串)的 值,描述异常信息
标准异常类的具体描述:
#include<stdexcept>
class Person{
public:
    Person(int age){
        if (age < 0 || age > 150){
            throw out_of_range("年龄应该在 0-150 岁之间!");
        }
    }
public:
    int mAge;
};
int main(){
    try{
        Person p(151);
    }
    catch (out_of_range&amp; ex){
        cout << ex.what() << endl;
    }
    system("pause");
    return EXIT_SUCCESS;
}

编写自己的异常类

        ① 标准库中的异常是有限的;
        ② 在自己的异常类中,可以添加自己的信息。(标准库中的异常类值允许设置一 个用来描述异常的字符串)。
如何编写自己的异常类?
        ① 建议自己的异常类要继承标准异常类。因为
C++
中可以抛出任何类型的异常, 所以我们的异常类可以不继承自标准异常,但是这样可能会导致程序混乱,尤其是 当我们多人协同开发时。
        ② 当继承标准异常类时,应该重载父类的
what
函数和虚析构函数。
        ③ 因为栈展开的过程中,要复制异常类型,那么要根据你在类中添加的成员考虑 是否提供自己的复制构造函数
//自定义异常类
class MyOutOfRange:public exception
{
public:
    MyOutOfRange(const string errorInfo)
    {
        this->m_Error = errorInfo;
    }
    MyOutOfRange(const char * errorInfo)
    {
        this->m_Error = string( errorInfo);
    }
    virtual ~MyOutOfRange()
    {
    }
    virtual const char * what() const
    {
        return this->m_Error.c_str() ;
    }
    string m_Error;
};
class Person
{
public:
    Person(int age)
    {
        if (age <= 0 || age > 150)
        {
            //抛出异常 越界
            //cout << "越界" << endl;
            //throw out_of_range("年龄必须在 0~150 之间");
            //throw length_error("长度异常");
            throw MyOutOfRange(("我的异常 年龄必须在 0~150 之间"));
        }
        else
        {
            this->m_Age = age;
        }
    }
    int m_Age;
};
void test01()
{
    try
    {
        Person p(151);
    }
    catch ( out_of_range &amp; e )
    {
        cout << e.what() << endl;
    }
    catch (length_error &amp; e)
    {
        cout << e.what() << endl;
    }
    catch (MyOutOfRange e)
    {
        cout << e.what() << endl;
    }
}

原文地址:https://blog.csdn.net/weixin_50963877/article/details/134694695

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。

如若转载,请注明出处:http://www.7code.cn/show_7637.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注