Re: Percentage of error checking code
Jorgen Grahn <grahn+nntp@snipabacken.se> wrote in
news:slrnkip1lg.ah7.grahn+nntp@frailea.sa.invalid:
On Sun, 2013-02-24, Paavo Helde wrote:
The wc program tells me there is approximately one 'throw' for each
100
lines
Ok, but throwing is less than half of the error handling. I suspect
that with error handling done really well, most of the effort has gone
into designing your objects so that stack unwinding Does The Right
Thing. You may not even recognize it as "error handling code".
The effort to produce RAII code should be taken anyway as basically
almost anything in C++ code may throw std::bad_alloc. And the design is
easy once one "has seen the light"; also, RAII is encapsulated in few
low-level classes. The amount of error handling code is reduced this way
as it is present only in one place and not scattered all over the place.
Compare with some C-style error handling:
int foo() {
FILE* f = fopen(...);
if (!f) {
// report error
return -1;
}
FILE* g = fopen(...);
if (!g) {
if (fclose(f)!=0) {
// report error
}
// report error
return -1;
}
// do some work
return 0;
}
int bar() {
if (foo()!=0) {
return -1;
}
// do more work
return 0;
}
int main() {
if (bar()!=0) {
return EXIT_FAILURE;
}
// do more work
return EXIT_SUCCESS;
}
Here the percentage of error handling lines is 14/31 = 45%.
In C++ this becomes (assuming there are valid reasons not to use
fstream):
class MyFile {
FILE* f_;
public:
MyFile(...) {
f_ = fopen(...);
if (!f_) {
throw ...;
}
}
~MyFile() {
if (fclose(f_)!=0) {
// report error
}
}
};
void foo() {
MyFile f(...);
MyFile g(...);
// do some work
}
void bar() {
foo();
// do more work
}
int main() {
try {
bar();
return EXIT_SUCCESS;
} catch(...) {
// report error
return EXIT_FAILURE;
}
}
Here the percentage of error handling code is 10/33 = 30%; what's more
important is because the error handling code is concentrated in the low-
level utility classes and top-level main, the ratio goes smaller and
smaller when the bulk of the actual application level code grows. The
ratio of error handling lines in the application logic level functions
foo() and bar() is 10/24 = 42% in C-style; in C++-style it is 0%!
Cheers
Paavo