Thread: calling functions and error messages

It sort of depends on:
1. the severity of the error.
2. the source of the error (programmer error [e.g. dividing by a number which turns out to be zero because of some math error in the previous calculations], user error [e.g. entering the name of a file which doesn't exist] or system error [e.g. out of memory because of some other application "eating" all the systems memory]).
3. What you can actually do at the time, and what you can do later one to resolve/report the error.

In some cases, the best approach is to stop now, in other cases, it's better to continue and report the error later. If you can't allocate memory, and the code following expects the memory to be there [and it couldn't possibly cope with it not being there], you may just as well throw the emergeny brake on and stop there.

Throwing an exception, by the way, doesn't have to stop the application. If the next level of code knows how to handle the exception, then you can just deal with it and (for example) try again.

Example:

Code:

void someFileFuncion(string filename)
{
    ifstream fin(filename.c_str());
    if (!fin) throw FileException(string("Could not open file: ") + filename);
    ... // other processing. 
}

void dofilestuff()
{
    string filename;
    bool failed;
    do 
    {
       failed = false;
       try {
          cout << "Enter file:";
          cin >> filename;
          someFileFunction(filename);
       } 
       catch(FileException e)
       {
         cout << e.message; 
         cout << "Please enter a valid filename\n";
         failed = true;
       }
    } while (failed);
}

--
Mats

Exceptions are very expensive. The best approach, if you ask me, is to allow both kinds of behavior depending on what you need.
If it's a chain code (ie, the following code needs the previous to be successful), then an exception can save you pain of goto and multiple code duplication on failure.
If the code will do the operation many times, or is not chain code, consider returning an error.

Yes, they take a long time to execute.
Throw an exception in a loop and see how many times you can loop before it comes slow. Then compare it when simply returning something and you'll see what a huge difference it makes.

I'd assume that read_config_file is not called very often, though, so this shouldn't matter.

I think, generally you should be able to recognize which parts of the program need to perform well and where it doesn't matter and not worry about small performance degradations in the latter parts if that makes the code simpler.