【Swift 3 && C++11】<第一

异常处理

|Swift|C++
:-:|:-:|:-:
关键字或类型|Error, throws, try, do - catch, try?, defer| throw, try...catch

C++中的异常处理机制包括:

• throw 表达式 异常检测部分使用throw 表达式来表示它遇到了无法处理的问题. 我们说throw 引发了异常.
• try 语句块, 异常处理部分使用try 语句块处理异常. try 语句块以关键字 try 开始, 并以一个或多个catch 子句结束.
• 一套异常类, 用于在 throw 表达式和相关的 catch 子句之间传递异常的具体信息.

先来介绍 Swift 中的错误处理内容.

Swift 中你可以使用任意的遵循了Error协议的类型来表示错误.

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

可以使用thow 来抛出一个错误并使用thows 来表示一个可以抛出错误的函数. 如果在一个函数中抛出了一个错误, 这个函数会立刻返回并且调用函数的代码会进行错误处理.

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

有多种方式用来进行错误处理. 一种方式是使用do-catch.在 do代码块中, 使用 try来标记可以抛出错误的代码. 在catch 代码块中,如果没有给错误命名,则默认为error:

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}

练习: 将 printer name 改为 "Never Has Toner" 使 sendToPrinter(_:) 函数抛出错误。

可以使用多个catch 块来处理特定的错误. 就像写 switch中的多个case一样:

do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}

练习: 在 do 代码块中添加抛出错误的代码。你需要抛出哪种错误来使第一个 catch 块进行接收?怎么使第二个和第三个 catch 进行接收呢?

另一种处理错误的方式是使用try?将结果转换为可选的. 如果函数抛出错误,该错误会被抛出并且结果为nil. 否则的话, 结果会是一个包含函数值的可选值:

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

可以使用defer 代码块来表示在函数返回前, 函数中最后执行的代码. 无论函数是否会抛出错误, 这段代码都将执行. 使用defer, 可以把函数调用之初就要执行的代码和函数调用结束时的扫尾代码写在一起,虽然这两者的执行时机截然不同:

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]

func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }

    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)

可以看出** Swift** 的错误处理由以下三部分组成:

• thow来抛出错误
• do-catch 或try? 来进行错误处理.
• Error 错误协议

其中thows 用来标记一个函数抛出异常的函数, 而do-catch 中do 代码块中使用try 来标记可以抛出错误的代码. 而使用defer 来表示不管函数是否抛出异常都会最后被执行的代码.

在** C++中**也可以使用throw 来抛出异常:

#include <iostream>
using namespace std;

void doSomething(int a) {
    if (a) {
        cout << "代码安全:" << a << endl;
    }else {
        throw "代码出错";
    }
}

int main() {
    
    doSomething(0);
    
    return 0;
}

如果你运行上面的例子, 你会发现程序直接崩溃在throw 那行, 这是因为程序发生了异常但没有被捕获,则它将调用标准库函数terminate终止当前程序.

catch子句可以用来捕获异常,即 try语句块:

#include <iostream>
using namespace std;

void doSomething(int a) {
    if (a) {
        cout << "代码安全:" << a << endl;
    }else {
        throw "参数出错";
    }
}

int main() {
    
    try {
        doSomething(0);
    } catch (const char * what) {
        cout << "错误描述:" << what << endl;
    }
    
    return 0;
}

注意到throw表达式throw "参数错误"中, "参数错误"被称为异常对象, 你可以抛出任意的异常对象,不管是int 类型的还是类类型.

而关键字catch 后面的小括号中的内容表示你想要在此 catch 子句中处理的错误类型, 可以带参数, 那么就可以处理它, 也可以不带参数,进行统一处理; 当然,你可以写多个 catch 子句, 处理不同类型的异常对象; 还可以用...表示捕获所有异常:

#include <iostream>
using namespace std;

class ErrorClass {
public:
    ErrorClass(int a):code(a) {}
    
    void errorDiscription() {
        cout << "错误代码:" << code << endl;
    }
    int code;
};

void doSomething(int a) {
    switch (a) {
        case 0:
            throw "参数不能为0";
            break;
        case -1:
            throw -1;
        case 1:
            throw ErrorClass(a);
        case -2:
            throw runtime_error("其他异常情况"); 
        default:
            cout << "参数正常: " << a << endl;
            break;
    }
}

int main() {
    
    try {
        doSomething(-2);
        cout << "如果抛出了异常, 这里将永远不会被执行" << endl;
        
    } catch (const char * what) {
        
        cout << "错误描述:" << what << endl;
    } catch (int) {
        
        cout << "int类型的异常对象" << endl;
    } catch (ErrorClass error) {
        
        error.errorDiscription();
        
    } catch (...){ // 捕获所有异常
        cout << "默认处理其他的异常" << endl;
    }
    
    return 0;
}

可以使用noexcept 说明指定某个函数不会抛出异常, 但是如果这个用noexcept 指定的函数实际上抛出了异常, 则程序会直接调用 terminate 终止程序:

void something() { // 普通函数, 可能会抛出异常
}
void doSomethingButError() noexcept { // 承诺不会抛出异常
    throw exception(); // 违反了异常说明
}

noexcept说明可以带 bool实参:

void recoup() noexcept(true); // recoup 不会抛出异常
void alloc(int) noexcept(false); // alloc 可能抛出异常

但更常见的是noexcept 说明 和noexcept 运算符一起使用, noexcept 运算符返回一个 bool 类型:

void g();
void f() noexcept(noexcept(g())); // f 和 g 的异常说明一致, g() 可能抛出异常的话, f() 也可能抛出异常; g()不抛出异常, 则 f()也不会抛出异常.

注意, noexcept 有两层意义: 当跟在函数参数列表后面时,它是异常说明符; 而当作为 noexcept 异常说明的 bool 实参出现时, 它是一个运算符.

Swift 中通过遵循Error 协议来使任意的类型表示错误, 而我们知道在 C++中可以使用继承,多重继承和虚继承来实现 Swift 中的协议.

虽然我们可以任意的对象作为异常对象, 当我们也可以继承便准库异常类来自定义我们自己的异常类, 然后抛出自定义异常类来达到同样的目的.

标准库异常类的继承体系

如上图所示, 在这个标准库异常类的继承体系中,层次越低,表示的异常情况就越特殊, 以下我们来设计一个我们自己的异常类:

#include <iostream>
using namespace std;

class my_runtime_error: runtime_error {
public:
    
    // explicit声明构造函数时, 它只能使用直接初始化的形式使用,
    // 并且编译器将不会在自动转换过程中使用该构造函数(即不会隐式转换)
    explicit my_runtime_error(const std::string s): runtime_error(s), str(s) {}
    
    const char *what() {
        return this->str.c_str(); // string 类型转换成 C 字符串
    }
    
    std::string str;
};

class my_logic_error : logic_error {
public:
    explicit my_logic_error(const std::string s): logic_error(s){}
    
    my_logic_error(const std::string s, const std::string discription): logic_error(s), logicDiscription(discription) {}
    
    const std::string logicDiscription;
};

// 使用我们自定义的异常类
void initSomething() {
    throw my_logic_error("逻辑错误:", "此时不应调用初始化函数");
}

void runSomething() {
    throw my_runtime_error("运行时错误: runSomething()");
}

int main() {
   
    try {
//        initSomething();
        runSomething();
    } catch (my_runtime_error error) {
        cout << error.what() << endl;
        
    } catch (my_logic_error error) {
        cout << error.logicDiscription << endl;
    }
    
    return 0;
}