22异常处理

最新推荐文章于 2022-11-13 16:46:57 发布
最新推荐文章于 2022-11-13 16:46:57 发布
阅读量465 收藏
点赞数
分类专栏： C++ 文章标签： c语言 异常处理

异常处理

1.处理错误的传统机制

传统的C语言在函数执行过程中遇到语法错误或者逻辑错误的时候，通过函数返回值表明所遇到的错误类型。

2.思想

在C++里面，通过异常，跨越函数来通知整个程序错误发生并对错误进行相应的处理。

  • C++的异常处理机制使得异常的引发和异常的处理不必在同一个函数中，这样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调用者可以再适当的位置设计对不同类型异常的处理。

  • 异常是专门针对抽象编程中的一系列错误处理的，C++中不能借助函数机制，因为栈结构的本质是先进后出，依次访问，无法进行跳跃，但错误处理的特征却是遇到错误信息就想要转到若干级之上进行重新尝试，如图

  • 异常超脱于函数机制，决定了其对函数的跨越式回跳。

总的来说，异常是为了在程序出错的时候能够捕获并判断错误类型，且对错误做出合理的处理。增强了程序的健壮性。

3.基本语法

  1. 若有异常则通过throw操作创建一个异常对象并抛掷。
  2. 将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try语句，然后执行try块内的保护段。
  3. 如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去。
  4. catch子句按其在try块后出现的顺序被检查。匹配的catch子句将捕获并处理异常（或继续抛掷异常）。
  5. 如果匹配的处理器未找到，则运行函数terminate将被自动调用，其缺省功能是调用abort终止程序。
  6. 处理不了的异常，可以在catch的最后一个分支，使用throw语法，向上扔。

案例1：被零整除案例

int divide(int x, int y )
{
    if (y ==0)
    {
        throw x;
    }
    return x/y;
}

void main()
{
    try
    {
        cout << "8/2 = " << divide(8, 2) << endl;
        cout << "10/0 =" << divide(10, 0) << endl;
    }
    catch (int e)
    {
        cout << "e" << " is divided by zero!" << endl;
    }
    catch(...)
    {
        cout << "未知异常" << endl;
    }

    cout << "ok" << endl;
    system("pause");
    return ;
}

案例2，类对象作为异常变量被抛出

class A{};
void f(){
  if(...) throw A();
}
void g(){
  try{
    f();
  }catch(A){
    cout<<“exception A\n”;
  }
}
int main(){
  g();
}

  • throw A将穿透函数f，g和main，抵达系统的最后一道防线——激发terminate函数．该函数调用引起运行终止的abort函数．

  • 最后一道防线的函数可以由程序员设置．从而规定其终止前的行为．

  • 修改系统默认行为：

    • 可以通过 set_terminate函数修改捕捉异常的默认处理器，从而使得发生处理不了的异常时，被自定义函数处理。
    • void myTerminate(){cout<<“HereIsMyTerminate\n”;}
    • set_terminate(myTerminate);
    • set_terminate函数在头文件exception中声明，参数为函数指针void(*)().

案例3
构造函数没有返回类型，无法通过返回值来报告运行状态，所以只通过一种非函数机制的途径，即异常机制，来解决构造函数的出错问题。

异常机制与函数机制互不干涉，但捕捉的方式是基于类型匹配。捕捉相当于函数返回类型的匹配，而不是函数参数的匹配，所以捕捉不用考虑一个抛掷中的多种数据类型匹配问题，因为函数返回值只会有一个。
比如：

class A{};
class B{};

int main()
{
    try
    {
        int     j = 0;    
        double  d = 2.3;    
        char    str[20] = "Hello";
        cout<<"Please input a exception number: ";
        int a; 
        cin>>a;
        switch(a)
        {
        case  1: 
            throw d;      
        case  2: 
            throw j;      
        case  3: 
            throw str;
        case  4: 
            throw A();      
        case  5: 
            throw B();
        default: 
            cout<<"No throws here.\n";    
        }
    }
    catch(int)
    {
        cout<<"int exception.\n";
    }
    catch(double)
    {
        cout<<"double exception.\n";
    }
    catch(char*)
    {
        cout<<"char* exception.\n";
    }
    catch(A)
    {
        cout<<"class A exception.\n";
    }
    catch(B)
    {
        cout<<"class B exception.\n";
    }
    cout<<"That's ok.\n";
    system("pause");
}

catch代码块必须出现在try后，并且在try块后可以出现多个catch代码块，以捕捉各种不同类型的抛掷。

异常机制是基于这样的原理：程序运行实质上是数据实体在做一些操作，因此发生异常现象的地方，一定是某个实体出了差错，该实体所对应的数据类型便作为抛掷和捕捉的依据。

  • 异常捕捉严格按照类型匹配
    异常捕捉的类型匹配之苛刻程度可以和模板的类型匹配媲美,它不允许相容类型的隐式转换,比如,抛掷char类型用int型就捕捉不到．例如下列代码不会输出“int exception.”，从而也不会输出“That’s ok.” 因为出现异常后提示退出
int main(){
  try{
    throw ‘H’;
  }catch(int){
    cout<<"int exception.\n";
  }
  cout<<"That's ok.\n";
}

4.栈解旋

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反。这一过程称为栈的解旋(unwinding)。


class MyException {};

class Test
{
public:
    Test(int a=0, int b=0)
    {
        this->a = a;
        this->b = b;
        cout << "Test 构造函数执行" << "a:" << a << " b: " << b << endl;
    }
    void printT()
    {
        cout << "a:" << a << " b: " << b << endl;
    }
    ~Test()
    {
        cout << "Test 析构函数执行" << "a:" << a << " b: " << b << endl;
    }
private:
    int a;
    int b;
};

void myFunc() throw (MyException)
{
    Test t1;
    Test t2;

    cout << "定义了两个栈变量,异常抛出后测试栈变量的如何被析构" << endl;

    throw MyException();
}

void main()
{
    //异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，
    //都会被自动析构。析构的顺序与构造的顺序相反。
    //这一过程称为栈的解旋(unwinding)
    try  
    {
        myFunc();
    }
    //catch(MyException &e) //这里不能访问异常对象
    catch(MyException ) //这里不能访问异常对象
    {
        cout << "接收到MyException类型异常" << endl;
    }
    catch(...)
    {
        cout << "未知类型异常" << endl;
    }

    system("pause");
    return ;
}

5.接口声明

  • 为了加强程序的可读性，可以在函数声明中列出可能抛出的所有异常类型，例如：
    void func() throw (A, B, C , D);//这个函数func（）能够且只能抛出类型A B C D及其子类型的异常。
  • 如果在函数声明中没有包含异常接口声明，则此函数可以抛掷任何类型的异常，例如：
    void func();
  • 一个不抛掷任何类型异常的函数可以声明为：
    void func() throw();
  • 如果一个函数抛出了它的异常接口声明所不允许抛出的异常，unexpected函数会被调用，该函数默认行为调用terminate函数中止程序。

6.异常类型和变量的生命周期

  • throw的异常是有类型的，可以是，数字、字符串、类对象。
  • throw的异常是有类型的，catch严格按照类型进行匹配。

    注意 异常对象的内存模型 。


传统处理错误 
//文件的二进制copy
int filecopy01(char *filename2, char *filename1 )
{
    FILE *fp1= NULL,  *fp2 = NULL;

    fp1 = fopen(filename1, "rb");
    if (fp1 == NULL)
    {
        return 1;
    }

    fp2 = fopen(filename2, "wb");
    if (fp1 == NULL)
    {
        return 2;
    }

    char buf[256];
    int  readlen, writelen;
    while ( (readlen = fread(buf, 1, 256, fp1)) > 0 ) //如果读到数据，则大于0 
    {
        writelen = fwrite(buf, 1, readlen, fp2);
        if (readlen != readlen)
        {
            return 3;
        }
    }

    fclose(fp1);
    fclose(fp2);
    return 0;
}


void main()
{
    int ret;
    ret = filecopy01("c:/1.txt","c:/2.txt");
    if (ret !=0 )
    {
        switch(ret)
        {
        case 1:
            printf("打开源文件时出错!\n");
            break;
        case 2:
            printf("打开目标文件时出错!\n");
            break;
        case 3:
            printf("拷贝文件时出错!\n");
            break;
        default:
            printf("发生未知错误!\n");
            break;
        }
    }
}
**throw int类型异常** 
/文件的二进制copy
void filecopy02(char *filename2, char *filename1 )
{
    FILE *fp1= NULL,  *fp2 = NULL;

    fp1 = fopen(filename1, "rb");
    if (fp1 == NULL)
    {
        //return 1;
        throw 1;
    }

    fp2 = fopen(filename2, "wb");
    if (fp1 == NULL)
    {
        //return 2;
        throw 2;
    }

    char buf[256];
    int  readlen, writelen;
    while ( (readlen = fread(buf, 1, 256, fp1)) > 0 ) //如果读到数据，则大于0 
    {
        writelen = fwrite(buf, 1, readlen, fp2);
        if (readlen != readlen)
        {
            //return 3;
            throw 3;
        }
    }

    fclose(fp1);
    fclose(fp2);
    return ;
}
**throw字符类型异常** 
//文件的二进制copy
void filecopy03(char *filename2, char *filename1 )
{
    FILE *fp1= NULL,  *fp2 = NULL;

    fp1 = fopen(filename1, "rb");
    if (fp1 == NULL)
    {
        throw "打开源文件时出错";
    }

    fp2 = fopen(filename2, "wb");
    if (fp1 == NULL)
    {
        throw "打开目标文件时出错";
    }

    char buf[256];
    int  readlen, writelen;
    while ( (readlen = fread(buf, 1, 256, fp1)) > 0 ) //如果读到数据，则大于0 
    {
        writelen = fwrite(buf, 1, readlen, fp2);
        if (readlen != readlen)
        {
            throw "拷贝文件过程中失败";
        }
    }

    fclose(fp1);
    fclose(fp2);
    return ;
}
**throw类对象类型异常** 
//throw int类型变量
//throw 字符串类型
//throw 类类型
class BadSrcFile 
{
public:
    BadSrcFile()
    {
        cout << "BadSrcFile 构造 do "<<endl;
    }
    ~BadSrcFile()
    {
        cout << "BadSrcFile 析构 do "<<endl;
    }
    BadSrcFile(BadSrcFile & obj)
    {
        cout << "拷贝构造  do "<<endl;
    }
    void toString()
    {
        cout << "aaaa" << endl;
    }

};
class BadDestFile {};
class BadCpyFile {};;

void filecopy04(char *filename2, char *filename1 )
{
    FILE *fp1= NULL,  *fp2 = NULL;

    fp1 = fopen(filename1, "rb");
    if (fp1 == NULL)
    {
        //throw new BadSrcFile();
        throw  BadSrcFile();
    }

    fp2 = fopen(filename2, "wb");
    if (fp1 == NULL)
    {
        throw BadDestFile();
    }

    char buf[256];
    int  readlen, writelen;
    while ( (readlen = fread(buf, 1, 256, fp1)) > 0 ) //如果读到数据，则大于0 
    {
        writelen = fwrite(buf, 1, readlen, fp2);
        if (readlen != readlen)
        {
            throw BadCpyFile();
        }
    }

    fclose(fp1);
    fclose(fp2);
    return ;
}
**测试** 
//结论：//C++编译器通过throw 来产生对象，C++编译器再执行对应的catch分支，相当于一个函数调用，把实参传递给形参。
void main()
{
    try
    {
         //filecopy02("c:/1.txt","c:/2.txt");
        // filecopy03("c:/1.txt","c:/2.txt");
         filecopy04("c:/1.txt","c:/2.txt");
    }
    catch (int e)
    {
        printf("发生异常：%d \n", e);
    }
    catch (const char * e)
    {
        printf("发生异常：%s \n", e);
    }
    catch ( BadSrcFile *e)
    {
         e->toString();
        printf("发生异常：打开源文件时出错!\n");
    }
    catch ( BadSrcFile &e)
    {
        e.toString();
        printf("发生异常：打开源文件时出错!\n");
    }
    catch ( BadDestFile e)
    {
        printf("发生异常：打开目标文件时出错!\n");
    }
    catch ( BadCpyFile e)
    {
        printf("发生异常：copy时出错!\n");
    }
    catch(...) //抓漏网之鱼
    {
        printf("发生了未知异常! 抓漏网之鱼\n");
    }
    //class BadSrcFile {};
    //class BadDestFile {};
    //class BadCpyFile {};; 
}
**综合案例** 

#include <iostream>
using namespace std;


//传统的错误处理机制
//throw int类型异常
void my_strcpy1(char *to, char *from)
{
    if (from == NULL)
    {
        throw 1;
    }
    if (to == NULL)
    {
        throw 2;
    }

    //copy是的 场景检查
    if (*from == 'a')
    {
        throw 3; //copy时出错
    }
    while (*from != '\0')
    {
        *to = *from;
        to ++;
        from ++;
    }
    *to = '\0';
}

//传统的错误处理机制
//throw char*类型异常
void my_strcpy2(char *to, char *from)
{
    if (from == NULL)
    {
        throw "源buf出错";
    }
    if (to == NULL)
    {
        throw "目的buf出错";
    }

    //copy是的 场景检查
    if (*from == 'a')
    {
        throw "copy过程出错"; //copy时出错
    }
    while (*from != '\0')
    {
        *to = *from;
        to ++;
        from ++;
    }
    *to = '\0';
}


class BadSrcType {};
class BadDestType {};
class BadProcessType
{
public:
    BadProcessType()
    {
        cout << "BadProcessType构造函数do \n";
    }


    BadProcessType(const BadProcessType &obj)
    {
        cout << "BadProcessType copy构造函数do \n";
    }

    ~BadProcessType()
    {
        cout << "BadProcessType析构函数do \n";
    }

};


//传统的错误处理机制
//throw 类对象 类型异常
void my_strcpy3(char *to, char *from)
{
    if (from == NULL)
    {
        throw BadSrcType();
    }
    if (to == NULL)
    {
        throw BadDestType();
    }

    //copy是的 场景检查
    if (*from == 'a')
    {
        printf("开始 BadProcessType类型异常 \n");
        throw BadProcessType(); //会不会产生一个匿名对象?
    }

    if (*from == 'b')
    {
        throw &(BadProcessType()); //会不会产生一个匿名对象?
    }

    if (*from == 'c')
    {
        throw new BadProcessType; //会不会产生一个匿名对象?
    }
    while (*from != '\0')
    {
        *to = *from;
        to ++;
        from ++;
    }
    *to = '\0';
}

void main()
{
    int ret = 0;
    char buf1[] = "cbbcdefg";
    char buf2[1024] = {0};

    try
    {
        //my_strcpy1(buf2, buf1);
        //my_strcpy2(buf2, buf1);
        my_strcpy3(buf2, buf1);
    }
    catch (int e) //e可以写 也可以不写
    {
        cout << e << " int类型异常" << endl;
    }
    catch(char *e)
    {
        cout << e << " char* 类型异常" << endl;
    }

    //---
    catch(BadSrcType e)
    {
        cout << " BadSrcType 类型异常" << endl;
    }
    catch(BadDestType e)
    {
        cout << " BadDestType 类型异常" << endl;
    }
    //结论1: 如果 接受异常的时候 使用一个异常变量,则copy构造异常变量.  
    /*
    catch( BadProcessType e) //是把匿名对象copy给e 还是e还是那个匿名对象
    {
        cout << " BadProcessType 类型异常" << endl;
    }
    */
    //结论2: 使用引用的话 会使用throw时候的那个对象
    //catch( BadProcessType &e) //是把匿名对象copy给e 还是e还是那个匿名对象
    //{
    //  cout << " BadProcessType 类型异常" << endl;
    //}

    //结论3: 指针可以和引用/元素写在一块 但是引用/元素不能写在一块
    catch( BadProcessType *e) //是把匿名对象copy给e 还是e还是那个匿名对象
    {
        cout << " BadProcessType 类型异常" << endl;
        delete e;
    }

    //结论4: 类对象时, 使用引用比较合适 

    // --
    catch (...)
    {
        cout << "未知 类型异常" << endl;
    }

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}


//传统的错误处理机制
int my_strcpy(char *to, char *from)
{
    if (from == NULL)
    {
        return 1;
    }
    if (to == NULL)
    {
        return 2;
    }

    //copy是的 场景检查
    if (*from == 'a')
    {
        return 3; //copy时出错
    }
    while (*from != '\0')
    {
        *to = *from;
        to ++;
        from ++;
    }
    *to = '\0';

    return 0;
}


void main41()
{
    int ret = 0;
    char buf1[] = "zbcdefg";
    char buf2[1024] = {0};

    ret = my_strcpy(buf2, buf1);
    if (ret != 0)
    {
        switch(ret)
        {
        case 1:
            printf("源buf出错!\n");
            break;
        case 2:
            printf("目的buf出错!\n");
            break;
        case 3:
            printf("copy过程出错!\n");
            break;
        default:
            printf("未知错误!\n");
            break;
        }
    }
    printf("buf2:%s \n", buf2);

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

结论1: 如果接受异常的时候使用一个异常变量,则copy构造异常变量. 调用拷贝构造函数。

结论2: 使用引用的话 会直接使用throw时候的那个对象。

结论3: 指针可以和引用/元素写在一块但是引用/元素不能写在一块。

结论4: 异常变量是类对象时, 使用引用比较合适

7.异常和继承

  • 由于异常变量可以是一个类对象，所以可以实现一个异常类
  • 异常类可以派生出子类，也可以继承自其他类
  • 父类引用或者指针指向子类对象可以实现多态，从而实现异常类框架，实现代码复用。

案例：设计一个数组类 MyArray

  • 重载[]操作，
  • 数组初始化时，对数组的个数进行有效检查
    • index<0 抛出异常eNegative
    • index = 0 抛出异常 eZero
    • index>1000抛出异常eTooBig
    • index<10 抛出异常eTooSmall
    • eSize类是以上类的父类，实现有参数构造、并定义virtual void printErr()输出错误。

#include <iostream>
using namespace std;

class MyArray
{
public:
    MyArray(int len);
    ~MyArray();
public:
    int & operator[](int index);
    int getLen();

    class eSize
    {
    public:
        eSize(int size)
        {
            m_size = size;
        }
        virtual void printErr()
        {
            cout << "size:" << m_size << " ";
        }
    protected:
        int m_size;
    };
    class eNegative : public eSize
    {
    public:
        eNegative(int size) : eSize(size)
        {
            ;
        }
        virtual void printErr()
        {
            cout << "eNegative 类型 size:" << m_size << " ";
        }
    };
    class eZero : public eSize
    {
    public:
        eZero(int size) : eSize(size)
        {
            ;
        }
        virtual void printErr()
        {
            cout << "eZero 类型 size:" << m_size << " ";
        }
    };
    class eTooBig : public eSize
    {
    public:
        eTooBig(int size) : eSize(size)
        {
            ;
        }
        virtual void printErr()
        {
            cout << "eTooBig 类型 size:" << m_size << " ";
        }
    };
    class eTooSmall : public eSize
    {
    public:
        eTooSmall(int size) : eSize(size)
        {
            ;
        }
        virtual void printErr()
        {
            cout << "eTooSmall 类型 size:" << m_size << " ";
        }
    };

private:
    int *m_space;
    int m_len;
};


MyArray::MyArray(int len)
{
    if (len  < 0)
    {
        throw eNegative(len);
    }
    else if (len == 0)
    {
        throw eZero(len);
    }
    else if (len > 1000)
    {
        throw eTooBig(len);
    }
    else if (len < 3)
    {
        throw eTooSmall(len);
    }
    m_len = len;
    m_space = new int[len];
}

MyArray::~MyArray()
{
    if (m_space != NULL)
    {
        delete [] m_space;
        m_space = NULL;
        m_len = 0;
    }
}

int & MyArray::operator[](int index)
{
    return m_space[index];
}

int MyArray::getLen()
{
    return m_len;
}

void main()
{

    try
    {
        MyArray a(-5);
        for (int i=0; i<a.getLen(); i++)
        {
            a[i] = i+1;
            printf("%d ", a[i]);
        }
    }
    catch(MyArray::eSize &e)
    {
        //cout <<  "len的大小: " << e.eSize();
        e.printErr();
    }
    catch (...)
    {
    }


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

// 不推荐
void main51()
{

    try
    {
        MyArray a(-5);
        for (int i=0; i<a.getLen(); i++)
        {
            a[i] = i+1;
            printf("%d ", a[i]);
        }
    }
    catch(MyArray::eNegative e)
    {
        cout << "eNegative 类型异常" << endl;
    }
    catch(MyArray::eZero e)
    {
        cout << "eZero 类型异常" << endl;
    }
    catch(MyArray::eTooBig e)
    {
        cout << "eTooBig 类型异常" << endl;
    }
    catch(MyArray::eTooSmall e)
    {
        cout << "eTooSmall 类型异常" << endl;
    }

    catch (...)
    {
    }


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

8.标准异常库

// out_of_range
#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");
}
小帅比simon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1.C++异常处理.docx
11-21
C++异常处理 C++异常处理是指在程序执行过程中出现异常情况时，采取相应的处理措施以避免程序崩溃或出错的机制。异常处理机制可以使程序更加稳定和可靠，提高程序的容错性和可维护性。 1. 异常捕获案例 在C++中，...
异常处理实验报告
最新发布
05-11
**异常处理实验报告** 实验报告主要探讨了面向对象程序设计中的C++程序结构以及数组与指针的使用，包括多文件结构的理解、动态内存分配、深复制与浅复制的概念及其应用。以下是实验涉及的主要知识点： 1. **多文件...
Linux shell script遇到unexpected operator错误
PanPan的专栏
02-20 455
解决： 因为ubuntu默认的sh是连接到dash的,又因为dash跟bash的不兼容所以出错了.执行时可以把sh换成bash 文件名.sh来执行.
ubuntu执行shell脚本常见出现报错问题
epmgy315的博客
08-11 499
oetsky@oetsky-virtual-machine:~$ sh 2.01_install_jdk.sh basename: missing operandTry 'basename --help' for more information.-e ---> :-e ---> 2022年08月11日 17时23分42秒：「JDK安装脚本」 检查脚本执行条件2.01_install...
some tips about shell variables
good_habits的专栏
05-18 425
1. 显示变量的长度：
刚学习shell,碰到问题.执行时总出错:unexpected operator（整理）
yuyiyunpiao的专栏
11-22 2199
刚学习 SHELL 好多不懂的地方 看鸟哥的书 它把'='写成'=='效果一样 但是我在运行时有错误提示 若写成=就好了 还有！=直接 使用是会有错误提示 如果写为（空格）！（空格）=（空格）的形式就会好了 注意空格的使用。 脚本如下： #!/bin/bash # Program: #      This program shows the user's choic
c++ try catch 问题
热门推荐
windhaunting的专栏
10-27 8万+
try{} catch(…){}以前都是用try{} catch(…){}来捕获C++中一些意想不到的异常， 今天看了Winhack的帖子才知道，这种方法在VC中其实是靠不住的。例如下面的代码：try { BYTE* pch ; pch = ( BYTE* )00001234 ;   //给予一个非法地址 *pch = 6 ; //对非法地址赋值，会造成Access V
python异常处理try except过程解析
12-20
Python异常处理是编程中至关重要的一个部分，它允许程序员优雅地处理可能出现的错误，确保程序在遇到问题时能够继续执行或提供有用的反馈。在Python中，`try-except`语句用于捕获并处理异常。当`try`块中的代码抛出...
Python：通用异常类型表
04-15
在Python编程语言中，异常处理是程序健壮性的重要组成部分。异常是程序运行时遇到的问题，它们可以打断正常的代码流程。Python提供了丰富的异常类型，这些异常被组织成一个层次结构，使得处理和捕获特定类型的错误...
优质Python教程 Python3.7从基础入门到精通进阶教程 第08章 程序调试和异常处理 共19页.ppt
02-20
第8章 程序调试和异常处理.ppt 第9章 模块与类库.ppt 第10章 日期和时间.ppt 第11章 迭代器、生成器与装饰器.ppt 第12章 文件与文件系统.ppt 第13章 基于thinter的GUI编程.ppt 第14章 Python的高级技术.ppt 第15章 ...
45.C++中的异常处理
qq_41583263的博客
11-13 455
异常的定义和抛出
shell靠谱判断条件写法，以及获取当前运行脚本绝对路径和名称方法
a96167653219的博客
03-13 355
Shell靠谱判断条件写法 判断一个用户是否是root用户，简单判断是 #!/bin/bash ROOT_UID=0 if ["$UID" -ne "$ROOT_UID" ] then echo "you are not root. " fi 然而，在bash下，$UID是可以正确获取到值，但是在dash环境下，$UID获取到的是空值，此...
C++异常
weixin_43510732的博客
08-08 172
C语言传统处理错误的方式： 1.终止程序。这就很恶心。直接导致程序崩溃。 2.返回错误码:在出现一些错误时，会返回错误码，程序员需要到错误码表中查找对应错误信息。 C++异常 概念：当一个函数发现自己无法处理一个错误时，它就通过抛异常的方式将异常给另一个函数来处理。这里引出了throw，catch，try。 throw：将会出现异常的变量用throw关键字来修饰。 catch：将想要处理异常交给c...
C++异常处理
潘志威
03-30 961
C＋＋异常处理建立在三个关键字基础之上：try、catch和throw。通常，监测异常情况的程序语句包含在try中。如果try块中发生了异常（也就是错误），则用throw处理。异常由catch捕获，并得到处理如前所述，抛出异常的语句必须在try块中执行（在try块中调用的函数也可能抛出异常）。任何异常必须由紧跟在抛出异常的try语句之后的catch语句捕获。try和catch的一般 形式如下：
解决 unexpected operator 报错问题
Be Like
02-27 9085
写了一个shell脚本，一直报如下错误： server.sh: 38: [: start: unexpected operator 解决方法一 将ubuntu 默认的 shell 链接的 dash 改成传统的 bash 执行如下命令： sudo dpkg-reconfigure dash 在弹出的框中选 no 解决方法二 将 == 改成 = ，因为在 dash 中默认的判断语句是 = ...
Linux Shell脚本 [ unexpected operator错误处理
SHELLCODE_8BIT的博客
06-20 3767
shell脚本[]中报unexpected operator，原因是使用了dash来做脚本解析，dash
Shell 判断语句出错 [: ==: unexpected operator
人人都懂物联网
05-28 5119
有时候，原来运行得好好的 shell 程序，换个平台就运行不了，例如下面 shell 程序。 #!/bin/sh if [ $1 == "hello" ]; then echo "Well done!" fi 在 Ubuntu 上运行，会出现如下的错误： [: ==: unexpected operator 这是因为 shell 脚本开头使用 #!/bin/sh，而不是 #!/bin/bash。而 /bin/sh 使用的是 dash，dash 中默认的判断语句是 =，而不是 bash 使用的
Exception转化为 String
非衣鲲化的博客
05-07 744
if (exception != null) { StringWriter stringWriter = new StringWriter(); PrintWriter pw = new PrintWriter(stringWriter); exception.printStackTrace(pw); ...
c++类型转换，异常，输入输出流
weixin_43767691的博客
07-19 247
c++类型转化，c++严格遵守类型匹配 静态转换static_cast的用法 1.用于类层次结构中基类和派生类指针或者引用之间的转换 子类---->父类（不安全） 父类----->子类（安全） 2.普通的类型转换 //基本类型转化 #include<iostream> using namespace std; int main() { char a =...
精通C++：优化技巧与异常处理
- ITEM9 和 ITEM10 关注异常处理，提倡在析构函数中防止资源泄漏，并确保构造过程中资源的安全。 - ITEM11 强调在异常处理中禁止异常信息传递到析构函数外部，以保持异常安全。 - ITEM12 比较了抛出异常和传递参数或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值