To “if, if, if” or to “if, else if, else if, else” [closed]

Answer 1

In terms of readability,

bool Test( SampleType sample )
{
    return SubTest1( sample )
        && SubTest2( sample )
        && SubTest3( sample );
}

is far clearer than either of your options. Otherwise, you definitely want the else to make it clear that once one of the conditions has been met, none of the others will be tested.

Answer 2

I can't imagine it will make any difference in performance.

I would use the first one if they were independent tests, and you just want to drop out after one them suceeds and the second one if it's choosing between a set of logical alternatives.

Answer 3

As far as I know, there's no difference in the resulted machine code. Besides that, who cares? Do you have a performance problem with this code? Performance is a difficult subject that usually should be left to the end of the project and only if there are performance problems they should be found and fixed WHERE THEY ACTUALLY EXIST and not where you think in advance they might be.

Answer 4

there is a good practice that is called "one point of entry, one point of exit". It means that it's better to have only one return in a function.

For now, your function is simple, but in the future, it may grow, become more complicated, allocate temporary variables which have to be freed, etc.

So it's better to use good practices everywhere. It's called "defensive programming", defense against human failures (mine and my colleagues').

I would write it this way :

bool Test(SampleType sample)
{
  bool bRet = true; // by default, set it to the most "defensive" value which will cause the less harm or make the problem evident

  // in the future, you may have inits and allocations here

  if ( !SubTest1(sample) )
    bRet = false; // don't match
  else if ( !SubTest2(sample) )
    bRet = false; // don't match
  else if ( !SubTest3(sample) )
    bRet = false; // don't match
  else
    ; // bRet stays true

  // thanks to the single point of exit, you can do things like that
  if (bRet)
     log("... match");
  else
     log("...no match")

  // here you clean temporary resources...

  return bRet;
}

If you want to improve performance, the best way is to put the SubTestX functions in the best order so that the one that doesn't match most often is first, so less tests are needed to find that it doesn't match.

Answer 5

Compiler generates the same code for both the versions. But the 1st version is better in maintainability aspect if you compare just with the 2nd version.

The code exits when the return statement is encountered; so there is no use of keeping else in the upcoming if. It makes the developer understand the code better.

Also, if this is the literal code then you can still shrink as,

bool Test(SampleType sample)
{
  return (SubTest1(sample) && SubTest2(sample) && SubTest3(sample));
}

Answer 6

Both are completely equivalent in terms of behavior and compilers will likely emit identical machine code for both.

They don't even differ that much in terms of readability - both have the same amount of nesting. Compare this to case where no early return leads to deep nesting.