这篇短文是讨论一个大多数程序员都感兴趣的一个话题:错误处理。错误处理是编程的一个“黑暗面”。它既是应用程序的“现实世界”的关键点,也是一个你想隐藏的复杂业务。
在早期的C编程生涯中,我知道三种错误处理的方式。
C语言的方式:返回错误码
C语言风格的错误处理是最简单的,但是并不完美。
C语言风格的错误处理依赖于“当程序遇到错误时返回一个错误码”。这里是一个简单的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
int
find_slash( const
char *str) { int
i = 0; while
(str[i] && str[i] != '/' ) i++; if
(str[i] == '\0' ) return
-1; //Error code //True value return
i; } // . . . if
(find_slash(string) == -1) { //error handling } |
使用这种方式的有什么好处?
你可以在调用函数之后直接处理错误码(在C语言中,你也会这样处理),显示一个错误消息或者直接终止程序。或者仅仅恢复程序最近的一个状态,终止计算。
当你找不到错误处理在哪里的时候,你只需要后头看看函数调用,错误处理就在那个附近。
使用这种方式有什么不好?
有人可能会告诉你,这种异常/错误处理方式和“执行逻辑”混在了一起。当你顺序地阅读这些代码的时候就行程序执行一样,你看到了一会错误处理,一会程序执行。这样很糟糕,你可能更喜欢只读程序执行逻辑或者错误处理逻辑。
并且你被限定使用错误码,如果你想要提供更多的信息,你需要创建一些功能函数比如:errstr或者提供全局变量。
使用C++的方式
C++作为对C的增强,引入了一种新的错误处理方式——异常。异常通过抛出一个错误的方式来中断正常代码执行逻辑,并可以被其他地方所捕获。下面是一个简单的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
int
find_slash( const
char *str) { int
i = 0; while
(str[i] && str[i] != '/' ) i++; if
(str[i] == '\0' ) throw
AnException( "Error message" ); //True value return
i; } // . . . try { find_slash(string); } catch (AnException& e) { //Handle exception } |
这样做的好处?
程序逻辑和错误处理分离了。一边你可以看到函数是如何工作的,而另一边你可以看到函数失败时候是怎么处理的。这样做很完美,可以很容易看出错误处理和正常程序逻辑。
另外,现在你可以为你的错误提供你需要的尽可能多的信息,因为你可以将需要的内容填充在自定义异常对象里。
这样做的坏处
编写详尽的异常处理变得很冗。你需要一个异常树,但是最好不要太大,这样,你可以选择捕获感兴趣的异常。同时,内部需要提供错误码,来获知究竟发生了什么,同时需要检索一些错误消息,等等。编写写异常类通常都是冗长,这是将信息嵌入到错误里来灵活处理更多的信息的成本。
这里的错误处理哲学是将错误尽可能推迟到需要处理的地方再处理,当你不知道程序执行过程究竟哪里会产生一个错误,你需要跳过不同的文件和功能函数来查找,这通常都是困难的,如果你在一个很深的调用树(这里意思是当你将函数调用绘制出一个图形,其形状类似一棵树)上引发了一个异常,你需要指定在哪里来处理这个异常,当它被处理的时候,它又是在哪里发生的。特别是当你的程序很大,又是很早之前编写,有恰巧设计不够良好的时候,就更加显得困难。而大多数商业项目都是这样。
所以我觉得“异常是危险的”。虽然它提供了一种良好的方式来处理错误——仅限于一些小项目,并且这里的调用图简单且易于掌握时候。
错误封装的模式
我这里把它叫做一种模式,所以人们不必害怕担心。后面,我会给它一种更好的命名,所以请不要着急。
错误封装的主旨是创建一种封装来包含错误消息或者错误的返回值。我们通常会选择字符串而不是其他,因为这也并不容易实现。我们尽力保证语法的可读性,可理解,并且容易应用。我们不处理拷贝构造或者多参数函数及返回值,这里仅给出一个尽可能简单的例子。
让我们以下面的例子开始:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
E< int > find_slash( const
char * str) { int
i = 0; while
(str[i] && str[i] != '/' ) i++; if
(str[i] == '\0' ) return
fail< int >( "Error message" ); //True value return
ret(i); } // . . . auto v = find_slash(string); if (!v) { //Handle exception } |
乍一看,这里有点类似C语言的风格,但是不是,为表明这一点,请看接下来的多个函数调用例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
E< int > find_slash( const
char *); E< int > do_some_arithmetic( int ); E<std::string> format( int ); E< void > display(std::string); auto v = ret(string) .bind(find_slash) .bind(do_some_arithmetic) .bind(format) .bind(display); if (!v) { //Handle error } |
好了,这里发生了什么?bind是一个成员函数来绑定你的函数调用,试着去应用它。如果错误装箱里面含有一个值,那么它就应用于函数调用,继续返回一个错误装箱(编译器不允许你返回一个不带错误装箱的函数)。
所以,我们链式调用了find_slashe,do_some_arithmetic, format和display.它们都不处理错误装箱,由于bind函数的作用,我们将函数E<something_out> f(something_in)
返回结果给E<something_out> f(E<something_in>)
函数做参数。
这里的好处是什么?
再一次,函数逻辑(调用链)和错误处理分离了。和异常一样,我们可以简单读一下函数调用链来了解代码逻辑,而不用关心执行是在哪里被中断的。事实上,函数调用链可以在任何调用时被中断。但是我们可以认为没有错误发生,如果我们的逻辑是正确的,可以很快速检查。
当然,类型推导会阻止你在调用display之后继续进行绑定。所以我们也没有失去类型能力。
注意,我们没有在其他地方调用这些函数,我们在最后将这些方法组装在一起。这里是关键,你应该编写一些小的模块函数(另外,注意:你应该编写模板函数使其工作)接收一个值,然后计算一个新值或者返回失败。在每一步中,你都不需要考虑可能出现错误导致你的控制流中断,并且校验你是否在一个有效的状态上(异常安全基于查询每个函数调用,指出函数是否中断你的控制流程,如果出现异常会发生什么),基于这一点,这样做更安全。
和异常一样,我们可以处理很详细的信息,尽管这里我们编写的是一个偏模板函数,所以也容易理解一些。
我们可以很容易放置异常处理逻辑,把它放在函数调用链之后(除非这个返回值还需要进一步被链接)。现在,我们有一个大的的执行流,没有中断,使用小的函数处理流程,容易定位。当需要添加一个新的错误时,你只需找到那些函数,通过函数调用链,你可以直接定位到处理位置,并根据需要添加。大型项目变得更加的线性化,并且更易读。
这样做有什么不足?
首先,这是一个新的处理方式,并且和C++的方式不兼容。这不是一个标准处理方法,当你使用stl时,你仍然需要使用异常。
对于我来说,这样做还是有点冗长。需要显式编写fail<int>(…)的模板推导显得有点怪异,如果你有个多态错误类型就更糟了,你不得不这样写fail<return_type, error_type>("...")
.
当函数有多个参数时编写也很困难,在其他一些语言中,可以使用适用类型和抽象类型很好地解决这个问题,不过这在C++中不会提供。我想更适合使用bind2(E<a>, E<b>, f)
和bind3(E<a>, E<b>, E<c>, f)
,可变模板参数功能更有用。
为获取封装错误中的值,我们需要检查这个值是否是有效值,接着调用一个“to_value”方法。我们没办法不通过检查来做到这一点。我们希望的是“解构”一个对象,不过这在C++中不支持,这也不是一些可以说“我们把它加入到下一个标准”的特性。
目前为止,我不知道读者是否有方法将其适配到成员函数中,如果你有想法,请测试一下,如果可以,请告知我们。
实现原子错误处理
我实现了它,我定义了这个黑魔法的名字——“原子化”,你可以认为“原子化”是一个对值和错误上下文的装箱,比如,一个box包含一个值或者什么也不包含是一个原子组(这里作为一个练习,你可以试着实现一下)。
有点奇怪的是,从某个角度来说队列是一个原子组,他们拥有一个上下文的值。
让我们从上面的E模版类实现开始,这里使用了C++11标准中的decltype和auto -> decltype类型,允许自动推导得到表达式的类型,这非常有用。
这里的bind函数有点怪异,但是他实现了我刚才提到的内容。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
/* This is the "Either String" monad, as a way to handle errors. */ template < typename
T> class
E { private : //The value stored T m_value; //The error message stored std::string m_error; //A state. True it's a value, false it's the message. bool
m_valid; E() {} public : //Encapsulate the value static
E ret(T v) { E box; box.m_value = v; box.m_valid =
true ; return
box; } //Encapsulate an error static
E fail(std::string str) { E box; box.m_error = str; box.m_valid =
false ; return
box; } //True if it's a valid value operator
bool ()
const { return
m_valid; } //Deconstruct an E to a value T to_value()
const { //It's a programmer error, it shouldn't happen. if
(!* this ) { std::cerr <<
"You can't deconstruct to a value from an error"
<< std::endl; std::terminate(); } return
m_value; } //Deconstruct an E to an error std::string to_error()
const { //It's a programmer error, it shouldn't happen. { std::cerr <<
"You can't deconstruct to an error from a value"
<< std::endl; std::terminate(); } return
m_error; } friend
std::ostream& operator<< (std::ostream& oss, const
E<T>& box) { if
(box) oss << box.m_value; else oss << box.m_error; return
oss; } template < typename
F> inline auto bind(F f) -> decltype(f(m_value)) { using
type = decltype(f(m_value)); if
(* this ) return
f(m_value); else return
type::fail(m_error); } }; |
这里,我重载了<<运算符,所以导出装箱中的内容更容易一些。我们并不是一定需要它,在“真”值时去掉这一点也更好一些。
这里的例子,我们需要一个“E<void>”类型,但是它可能不一定使用。我们需要为void实现一个特别的重载,这里其实也是一样的,只不过期望的值是一个“空箱”。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
/* Special instance for void */ template <> class
E< void > { private : std::string m_error; bool
m_valid; E() {} public : //Encapsulate the value static
E ret() { E box; box.m_valid =
true ; return
box; } //Encapsulate an error static
E fail(std::string str) { E box; box.m_error = str; box.m_valid =
false ; return
box; } //True if it's a valid value operator
bool ()
const { return
m_valid; } //Déconstruct an E to a value void
to_value() const { //It's a programmer error, it shouldn't happen. if
(!* this ) { std::cerr <<
"You can't deconstruct to a value from an error"
<< std::endl; std::terminate(); } } //Deconstruct an E to an error std::string to_error()
const { //It's a programmer error, it shouldn't happen. if
(* this ) { std::cerr <<
"You can't deconstruct to an error from a value"
<< std::endl; std::terminate(); } return
m_error; } friend
std::ostream& operator<< (std::ostream& oss, const
E< void >& box) { if
(box) oss <<
"()" ; else oss << box.m_error; return
oss; } template < typename
F> inline auto bind(F f) -> decltype(f()) { using
type = decltype(f()); if
(* this ) return
f(); else return
type::fail(m_error); } }; |
我们没有提到ret和fail方法,事实上,它们只是对xxx::fail和xxx::ret函数的封装。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/* Then, I introduced those simple functions, to reduce the call to something readable/writable */ template
< typename
T> inline E<T> ret(T v) { return
E<T>::ret(v); } template
< typename
T> inline E<T> fail(std::string err) { return
E<T>::fail(err); } |
这里,你可以编译并执行一下上面的代码。
如果你想要更多的,可以试试下面这个更具体一点的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/* Here come a case of use. */ // What a user would see: //Return a value in an error context template
< typename
T> inline E<T> ret(T v); //Fail in an error context of type T template
< typename
T> inline E<T> fail(std::string err); // What a user would write: typedef
std::vector<std::string> vs; typedef
std::string str; //Parse a +- formated string. //If a letter is prefixed by +, then the function toupper is applied. //'' tolower is applied. //Non alphabetical (+ and - excepted) aren't alowed. //Words are cut on each space ' '. Other blank characters aren't alowed. E<std::vector<std::string>> parse(std::string str) { int
mode = 0; vs vec; if
(str.empty()) return
fail<vs>( "Empty string aren't allowed" ); std::string stack; for ( int
i = 0; str[i] != '\0' ; i++) { switch (str[i]) { case
'-' : mode = 1; break ; case
'+' : mode = 2; break ; case
' ' : { if (!stack.empty()) vec.push_back(stack); stack.resize(0); mode = 0; break ; } default : { if
(! isalpha (str[i])) return
fail<vs>( "Only alpha characters are allowed" ); if
(mode == 1) stack.push_back( tolower (str[i])); else
if (mode == 2) stack.push_back( toupper (str[i])); else stack.push_back(str[i]); mode = 0; break ; } } } if (!stack.empty()) vec.push_back(stack); return
ret(vec); } //Take the first word and append it to the begining of all other words. //Vec should contain at least one element. E<std::vector<std::string>> prefixy(std::vector<std::string> vec) { if
(vec.empty()) return
fail<vs>( "Can't add prefixes on an empty table" ); std::string prefix = vec.front(); vs out; for
(auto s : vec) { if
(prefix == s) continue ; out.push_back(prefix + s +
"^" ); } return
ret(out); } //Concatenate all strings as a big string. Vec should contain data. E<std::string> concat(std::vector<std::string> vec) { std::string output; if
(vec.empty()) return
fail<str>( "Empty vectors aren't allowed" ); for
(auto s : vec) output += s; if
(output.empty()) return
fail<str>( "No data found" ); return
ret(output); } int
main() { typedef
std::string s; //Parse some string, show how error interrupt computation of the "chain". std::cout << ret((s) "+hello -WORLD" ).bind(parse).bind(prefixy).bind(concat) << std::endl; std::cout << ret((s) "+hello Hello Hello" ).bind(parse).bind(prefixy).bind(concat) << std::endl; std::cout << ret((s) "+ " ).bind(parse).bind(prefixy).bind(concat) << std::endl; std::cout << ret((s) "+hi" ).bind(parse).bind(prefixy).bind(concat) << std::endl; //Play with lambda to "replace" a value if it's not an error. std::cout << ret((s) "Some string" ).bind([]( const
std::string&) { return
fail<s>( "Failed" );}); std::cout << ret(23).bind([]( const
int ) { return
ret(42);}); std::cout << fail< int >( "NaN" ).bind([]( const
int ) { return
ret(42);}); return
0; |