C++学习笔记_10 异常处理 2021-04-27

// C++学习笔记_10 异常处理
#include <iostream>
#include<string>
#include<exception>
using namespace std;
int mydiv(int x, int y)
{
    //if (y == 0) return -1; //return 什么都不合适
    if (y == 0)     throw "除数为0"; //抛出异常
    if (x < y)  throw 0; //x < y 的时候，抛出 0
    if (y == 3) throw 333; 
    if (y == 5) throw 1.1;
    return x / y;
}
void TestException()
{
    //处理异常 ： try {xxx}  catch(xx) {}
    int arr[] = { 2, 0, 3, 20, 5 };
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){
        try{
            int x = mydiv(10, arr[i]);
            cout << "x:" << x << endl;
        }
        catch (char* s)  //遇到异常，程序进入异常处理，处理完成后，程序继续跑
        //抛出的异常类型，是一个字符串的话，进入这个分支。使用 s 来接受抛出的字符串
        {cout << "Exception: " << s << endl;}
        catch (int x){cout << "Exception: " << x << endl;}
        catch (...) //捕获所有其它异常，相当于 switch case 内的default
        { cout << "Exception: Default" << endl;}
    }     
}
//一般情况下，我们要自定义异常类
class MyException :public exception
{
private:
    int errNo;  
    char* str(int err) const
    {
        static char errMap[][30] =
        {
            "成功",
            "第一类错误",
            "第二类错误",
            "第三类错误"
        }; 
        if (err < sizeof(errMap) / sizeof(errMap[0]))
        {
            return errMap[err];
        }
        return "未知错误";
    }
public:
    MyException() :errNo(0) {} 
    MyException(int err) :errNo(err){}
    int err()
    { 
        return errNo; 
    }    
    friend ostream& operator << (ostream &os, const MyException &exp)
    {
        os << "errno:" << exp.errNo << ":" << exp.str(exp.errNo);
        return os;
    }
};
void DisposeXXX(int i)
{
        if (i == 0) throw MyException();
        else if (i == 1) throw MyException(1);
        else throw MyException(i);       
}
void TestMyException()
{
    for (int i = 0; i < 5; i++){
        try { DisposeXXX(i);}
        catch (MyException e) {cout << e << endl;}
    }
}
class CStudent
{
private:
    static int CNT;
    static int FLAG;
    int id;
public:
    CStudent()
    {id = GenId();} //构造学生，生成学号，要求学号不能重复
    //实现一个生成学号的函数 --> 使用静态函数
    static int GenId()
    {
        //其它计算 ....
        //如果这里 处理比较复杂，多线程处理的时候可能出现一个情况：
        //多个对象同时调用这个函数。
        //  取值的时候取到的CNT 是一样的 --> 学号重复
        //怎么处理？ --》定义互斥变量 FLAG （静态成员）
        while (FLAG);
        FLAG = 1;       //互斥，处理完成前，其它对象空转
        //..... 耗时的处理
        CNT++;
        //...处理完毕后，打开互斥变量
        FLAG = 0;
        return CNT;
    }
    int getid() { return id;}
};
int CStudent::CNT = 0;
int CStudent::FLAG = 0;
CStudent Fudaoyuan1(){return CStudent();}
CStudent Fudaoyuan2(){return CStudent();}
void TestStudent()
{
    CStudent *pStudent = (CStudent*)malloc(30 * sizeof(CStudent));
    for (int i = 0; i < 30; i++)
    {
        int x = rand() % 2;
        //假装这里是多线程
        if (x & 1) pStudent[i] = Fudaoyuan1();
        else       pStudent[i] = Fudaoyuan2();
    }
    for (int i = 0; i < 30; i++)
        cout << "学号:" << pStudent[i].getid() << endl;
}
int  main( )
{       
    //TestException();
    //TestMyException();
    TestStudent();
  return 0;
}