Question

assume you have a function that polls some kind of queue and blocks for a certain amount of time. If this time has passed without something showing up on the queue, some indication of the timeout should be delivered to the caller, otherwise the something that showed up should be returned.

Now you could write something like:

class Queue
{
    Thing GetThing();
}

and throw an exception in case of a timeout. Or you
write

class Queue
{
    int GetThing(Thing& t);
}

and return an error code for success and timeout.

However, drawback of solution 1 is that the on a not so busy queue timeout is not an exceptional case, but rather common. And solution 2 uses return values for errors and ugly syntax, since you can end up with a Thing that contains nothing.

Is there another (smart) solution for that problem? What is the preferred solution in an object oriented environment?

Answer 1

I would use exceptions only when the error is serious enough to stop the execution of the application, or of any big-enough application’s component. But I wouldn’t use exceptions for common cases, after which we continue the normal execution or execute the same function again. This would be just using exceptions for flow control, which is wrong.

So, I suggest you to either use the second solution that you proposed, or to do the following:

class Queue
{
    bool GetThing(Thing& t); // true on success, false on failure
    string GetLastError(); 
};

Of course you can stick with an int for an error code, instead of a string for the full error message. Or even better, just define class Error and have GetLastError() return it.