Thread: Classes and error handling

Originally Posted by Prelude

>I'm not sure if I follow you on this one, Prelude...
Exceptions are a bulky and time consuming process in C++. As such, they should be reserved for truly abnormal behavior to avoid the overhead and code bloat. Let's assume that giving the user control over something produces a random correct/incorrect result over a controlled sequence. That said, we can expect about 50% of the files that the user wants to open to have some kind of problem that would cause the open to fail (misspelled name, wrong directory, non-existent file, etc...). A failure condition for half of the requests is not abnormal behavior, so throwing an exception isn't the best option for a user controlled file open.

Speed of execution is rarely a consideration in most cases where you need to open files. It's rare to do anything like opening files in a time-critical section of code (if for no other reason than opening files is itself time-consuming). After a failed open, your program is almost certainly going to be idle and waiting for user input to confirm whether it should abort/retry/whatever, and whether that dialog pops up in 0.05 seconds or 0.07 seconds isn't really a big deal. The user won't visually see a difference.

In general I think the benefits of throwing an exception outweigh the negligible performance hit.

As for the try block, I hope you don't mean "terminate program here" by means of the terminate function or anything similar. If you want you can log the error and do any cleaning you may feel like... but the proper way to terminate is to rethrow the error afterwards.

That's what I thought . So the correct way would be

Code:

try {
    something = new char[somesize];
}
catch (...) {
    //log it
    throw FatalError;
}

... and if user is smart enough, they might even figure out what to do about FatalError?

As for the speed question, yes, in this particular constructor speed would not matter. However, speed might be a concern if I did exception handling with read/write operations, which might be in loops. I'll just need to test and see if that would be that bad.
[edit]
But then. If the first error is encountered, the error handler should exit the loop after all?! Would there be enormous overhead then?

You can use "throw" to re-throw the current exception (at least you can in Java, I'm not sure about C++). [edit] Yes, you can do it in C++, I just checked.

Code:

#include <iostream>

class e {};

int main() {
    try {
        throw e();
    }
    catch(e x) {
        throw;
    }
    
    return 0;
}

No errors.
[/edit]
[edit=2] Wait, it's throw() as Mario F. pointed out. Too much Java programming. [/edit]

Originally Posted by anon

... and if user is smart enough, they might even figure out what to do about FatalError?

Nah. No need. You just need to write thow();after the logging stuff.

Code:

/* ... */
catch ( /* ... */ ) {
   // logging code;
   throw();
}

/* ... */

That will rethrow the exception and propagate it up in the call stack. Without any proper error handling, the application will terminate.

I just tested some code on MS VC++:

Code:

#include "windows.h"
#include <iostream>
#include <string>
#include <stdexcept>


int Fail(){
	return 1;
}

void Throw(){
	throw std::runtime_error("Failure condition detected!\n");
}



int main(int, char**){

	const int count = 10000;

	LARGE_INTEGER time0,time1,time2;

	QueryPerformanceCounter(&time0);
	for (int i = 0; i < count; i++){

		if (Fail()){
			std::cout << "Failure condition detected!\n";
		}
	}
	QueryPerformanceCounter(&time1);
	for (int i = 0; i < count; i++){

		try{
			Throw();
		}
		catch (std::runtime_error s){
			std::cout << s.what();
		}
	}
	QueryPerformanceCounter(&time2);

	std::cout.flush();

	std::cout << "Error code: " << (time1.QuadPart-time0.QuadPart) << " us" << std::endl;
	std::cout << "Exception:  " << (time2.QuadPart-time1.QuadPart) << " us" << std::endl;

}

The results on this test are variable -- multiple runs through the code show almost equal time; sometimes one is faster, sometimes the other.

Overall, the time difference between a single throw() and a single error return is on the order of 500 nanoseconds (0.0000005 seconds) which in most cases is not going to be your speed-limiting factor.

Did you optimise your code?

What you should do is pass -s to g++ to get the equivalent assembly code.

Yeah, that was release mode with all optimizations for speed enabled.

Well then it might have optimised it to be the same thing. Which means that it doesn't matter which you use.