Using nested if statements to structure code

Question

I'm trying to structure my code in a readable way. I've read that one way of doing it is as follows:

if(Init1() == TRUE)
{
    if(Init2() == TRUE)
    {
        if(Init3() == TRUE)
        {
            ...
            Free3();
        }
        Free2();
    }
    Free1();
}

I like this way of doing things, because it keeps each FreeX inside its matching InitX loop, but if the nesting goes beyond three levels it quickly becomes unreadable and goes way beyond 80 columns. Many functions can be broken up into multiple functions so that this doesn't happen, but it seems dumb to break up a function just to avoid too many levels of nesting. In particular, consider a function that does the initialization for a whole class, where that initialization requires ten or more function calls. That's ten or more levels of nesting.

I'm sure I'm overthinking this, but is there something fundamental I'm missing in the above? Can deep nesting be done in a readable way? Or else restructured somehow whilst keeping each FreeX inside its own InitX loop?

By the way, I realise that the above code can be compacted to if(Init1() && Init2()..., but the code is just an example. There would be other code between each InitX call that would prevent such a compaction.

Answer 1

Since you included the C++ tag, you should be using RAII - Resource Acquisition Is Initialization. There's a bunch of good online resources explaining this concept, and it will make a lot of things pertaining to resource management a lot easier.

Answer 2

I'm sure I'm overthinking this, but is there something fundamental I'm missing in the above? [...] Or else restructured somehow whilst keeping each FreeX inside its own InitX loop?

Yes. This is a textbook case of code that will benefit enormously from RAII code:

instead of the construct:

if(init(3) == TRUE)
{
    free3();
}

consider this:

raii_resource3 r3 = init3(); // throws exception if init3 fails
                             // free3 called internally
                             // by raii_resource3::~raii_resource3

Your full code becomes:

raii_resource1 r1 = init1();
raii_resource2 r2 = init2();
raii_resource3 r3 = init3();

You will have no nested ifs, your code will be clear and straightforward (and focusing on the positive case).

You will just have to write RAII wrappers for resources 1, 2 and 3.

Answer 3

As others have pointed out, the obvious answer is RAII. But if the issue of overly deep nesting comes up without RAII, you should really ask yourself if you aren't making your functions too complicated. A function should rarely have more than about ten lines (including such checks). If you look at real cases, you'll find that it almost always makes more sense to break the function up. Even with RAII, you should generally only have one instance of an RAII class per function. (There are exceptions, of course; arguably, something like std::lock_guard shouldn't count.)

Answer 4

What i would recommend would be to use a switch statement. I'm a big fan of switch statements when it comes down to code like this

Hope this helps.

switch (i) {
    case 1:
        // action 1
        break;
    case 2:
        // action 2
        break;
    case 3:
        // action 3
        break;
    default:
        // action 4
        break;
}

Answer 5

You may have heard that gotos are evil, But if you are sticking to c, there is nothing "dirty" about using gotos to handle exceptions like this:

foo()
{
  if (!Init1())
    goto Error1;
  if (!Init2())
    goto Error2;
  ...
  ...
Error2:
  Free2();
Error1:
  Free1();
}