Elegant way to perform multiple dependent error checks in C++ without goto, and without early return?

Question

Let's say I want to call four functions consecutively, which operate on some object of mine. If any of them fails, I want to return FAILURE without calling the others, and I want to return SUCCESS iff all of them completed successfully.

Normally, I would do something like this:

if(function_zero(&myMutableObject) == SUCCESS)
{
    return FAILURE;
}
if(function_one(&myMutableObject) == SUCCESS)
{
    return FAILURE;
}
if(function_two(&myMutableObject) == SUCCESS)
{
    return FAILURE;
}
if(function_three(&myMutableObject) == SUCCESS)
{
    return FAILURE;
}

return SUCCESS;

Or, if I needed to do some cleanup:

if(function_zero(&myMutableObject) == SUCCESS)
{
    status = FAILURE;
    goto cleanup;
}
if(function_one(&myMutableObject) == SUCCESS)
{
    status = FAILURE;
    goto cleanup;
}
if(function_two(&myMutableObject) == SUCCESS)
{
    status = FAILURE;
    goto cleanup;
}
if(function_three(&myMutableObject) == SUCCESS)
{
    status = FAILURE;
    goto cleanup;
}

cleanup:
// necessary cleanup here
return status;

However, the project I am working on has some restrictions:

• No goto, ever
• No early return (one return per function)
• Line length limit
• (EDIT) No exceptions.
• (EDIT) No templates.

This leads me to something like this:

if(function_zero(&myMutableObject) == SUCCESS)
{
    if(function_one(&myMutableObject) == SUCCESS)
    {
        if(function_two(&myMutableObject) == SUCCESS)
        {
            status = function_three(&myMutableObject);
        }
        else
        {
            status = FAILURE;
        }
    }
    else
    {
        status = FAILURE;
    }
}
else
{
    status = FAILURE;
}

return status;

Unfortunately, this pushes me up against the line length limit often.

My question to you is: Is there a simpler way of writing this?

Notes & Restrictions:

• I must implement this logic within the code block implied here. I cannot create new functions, refactor or change the overall architecture.
• (EDIT) In reality the functions have very different signatures.

Answer 1

Use exceptions and RAII. These are literally the problems they were invented to solve. Exceptions though are more of a system-wide feature, rather than something you can apply locally.

For the cleanup block, RAII is exactly the feature you need.

For the success/failure, we can use lambdas and variadics to chain them together implicitly.

Now we can simply write them as lambdas in the list.

status f() {
    struct nested {
        static template<typename F> status_t Check(F f) {
            return f();
        }
        static template<typename F, typename... Chain> status_t Check(F f, Chain... chain) {
            auto status = f();
            return status != failure ? Check(chain...) : status;
        }
    };
    return nested::Check( 
        [] { return function_zero(&myMutableObject); },
        [] { return function_one(&myMutableObject); },
        [] { return function_two(&myMutableObject); },
        [] { return function_three(&myMutableObject); },
    );
}

This becomes slightly more problematic if you need to capture the return value, but since it seems to be always an error code with out parameter, it should be fine if you simply declare the receiving variable in f(), then all the future lambdas can refer to it. It also does not require that every function has the same signature, or allocating various data structures.

Answer 2

Only call the tests if status is currently set to SUCCESS using an && operator. If it is set to FAILURE the && will fail immediately and the subsequent tests will not be executed.

status = SUCCESS

if (status == SUCCESS && function_zero(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
if (status == SUCCESS && function_one(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
if (status == SUCCESS && function_two(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
if (status == SUCCESS && function_three(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}

return status;

As @Mooing Duck suggested, you could simply do it all in an else if chain:

status = SUCCESS

if (function_zero(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
else if (function_one(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
else if (function_two(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}
else if (function_three(&myMutableObject) == FAILURE)
{
    status = FAILURE;
}

return status;

Answer 3

A pattern that I used several times when dealing with a long chain of C calls (typically WinAPIs) goes like this:

bool ret =
    function_zero(&myMutableObject) == SUCCESS
    &&
    function_one(&myMutableObject) == SUCCESS
    &&
    function_two(&myMutableObject) == SUCCESS
    &&
    function_three(&myMutableObject) == SUCCESS;
if(!ret)
{
    // cleanup
}
return ret?SUCCESS:FAILURE;

You may even leave the && at the end of each line, so that it looks more like a "normal" sequence of calls (although personally I like them better this way, it's clearer what's going on).

The && operator guarantees execution in the right order and only if the previous calls succeeded, and introduces the necessary sequence points (or however they are called in C++11) between the calls, so the order of evaluation of parameters between the various calls is well defined. Also, it has low enough priority not to require additional parentheses.

If you are not afraid of using COM-style macros, you can also encapsulate the == SUCCESS check in a macro, like

// in some header, maybe with a less abused name
#define OK(x) ((x) == SUCCESS)

bool ret =
    OK(function_zero(&myMutableObject))
    &&
    OK(function_one(&myMutableObject))
    &&
    OK(function_two(&myMutableObject))
    &&
    OK(function_three(&myMutableObject));
// ...

Even better, if SUCCESS != 0 and FAILURE == 0 you can drop the OK() and == SUCCESS altogether and just use && to link the calls.

Answer 4

You say no exceptions, but I think you ought to know what you're giving up with that.

If you use RAII based cleanup and report errors as exceptions rather than codes, then you get code that looks like this:

function_zero(&myMutableObject);
function_one(&myMutableObject);
function_two(&myMutableObject);
function_three(&myMutableObject);

Here's a site that explains correct C++ exception handling and the benefits:

http://exceptionsafecode.com/

Some of the benefits are:

• easier to read
  • easier to understand and maintain
  • wrong code looks wrong
• easier to write
• improved performance on the success path
  • 'zero-cost' exceptions
  • compiler understands exceptions as a language feature, knows which path is the success path and which is the failure path
  • code size increase for exception tables is offset by elimination of error checking code

---

Furthermore, Herb Sutter has this to say on the subject of 'single exit' (the common name for your "No early return" rule):

In general, note that SE/SE is an obsolete idea and has always been wrong. “Single entry,” or the idea that functions should always be entered in one place (at their start) and not with goto jumps from the caller’s code directly to random places inside the function body, was and is an immensely valuable advance in computer science. It’s what made libraries possible, because it meant you could package up a function and reuse it and the function would always know its starting state, where it begins, regardless of the calling code. “Single exit,” on the other hand, got unfairly popular on the basis of optimization (‘if there’s a single return the compiler can perform return value optimization better’—see counterexample above) and symmetry (‘if single entry is good, single exit must be good too’) but that is wrong because the reasons don’t hold in reverse—allowing a caller to jump in is bad because it’s not under the function’s control, but allowing the function itself to return early when it knows it’s done is perfectly fine and fully under the function’s control.

http://herbsutter.com/category/c/gotw/page/4/

You should try to get the rules updated, even if that's only possible for new projects.

Answer 5

You could store the function pointers in a containers of std::function (as long as they have the same signature as in the example):

std::vector<std::function<error_code (myobject&)> functions { func1, func2, func3, func4 };

error_code status = SUCCESS;
for (const auto& f : functions) {
    if (f(myobject) == ERROR) {
        clean_up();
        status = ERROR;
        break;
    }
}

return status;

Answer 6

This could work:

bool success = true;
success = success && function_zero(&myMutableObject) != FAILURE;
success = success && function_one(&myMutableObject) != FAILURE;
success = success && function_two(&myMutableObject) != FAILURE;
success = success && function_three(&myMutableObject) != FAILURE;

return success ? SUCCESS : FAILURE;

return can be replaced to:

int status = SUCCESS;
if( !success ) status = FAILURE;
return status;

if in your company conditional operator is prohibited as well.

Answer 7

You might write a simple local functor:

bool fn0(int&) { return false; }
bool fn1(int&) { return false; }
bool fn2(int&) { return false; }

int main() {
    struct Test {
        const bool result;

        typedef bool (*function)(int&);
        Test(function f, int& value)
        :   result(f(value))
        {};

        operator bool () const { return result; }
    };

    int value;
    return Test(fn0, value)
        && Test(fn1, value)
        && Test(fn2, value);

}