Is there a performance difference by excluding an 'Else' clause?

Question

Is there a performance difference between the following two pieces of code?

if (myCondition)
{
     return "returnVal1";
}

return "returnVal2"

and

if (myCondition)
{
     return "returnVal1";
}
else
{
     return "returnVal2";
}

My gut feeling is that the compiler should optimize for this and there shouldn't be a difference, but I frequently see it done both ways throughout our code. I'd like to know if it comes down to a matter of preference and readability.

Answer 1

I'm pretty certain the compiler will optimize that out. Do what is most readable/follows convention for you and let the compiler handle simple things like that.

Even if it was not optimized, the performance difference would be pretty negligible.

Answer 2

With regards to the question, no it will not have a performance issue unless the case you are always evaluating turns out to be the else clause.

As stated in comments, you should just return the myCondition. However, you should always include an else clause for readability. If the else does nothing, then state so, with the classic comment of:

//do nothing

It helps developers looking at the code after it's written to realize that the else case was considered, but that there is no situation where it exists. It's also a good place to document why there ISN'T an else.

The example where a performance hit would occur is the following:

int x = 2;

if x != 2 {
     return true;
} else {
     return false;
}

The case being that it will always checks the if clause, fails, and therefore has to check the else clause.

Edit: If the else clause does nothing, the compiler will skip it -- it just comes in handy for reading purposes of other developers. it can also make your code more concise:

if(x=2) {
      doThis();
}
if(x!=2){
      doThat();
}

can get confusing and is easily combined into:

if(x==2){
     doThis(); 
} else {
     doThat();
}

Answer 3

If your compiler does not optimize it to the same bytecode, throw it out of the window!

Answer 4

While the optimization is a good thing, readability plays an important thing as well, so if you think if helps readability it's better than the nanosecond you save. IMHO

Answer 5

The best way to find out is to look at the code! Here's the code the VS2005 C# produced in release mode:

 static bool F1 (int condition)
 {
   if (condition > 100)
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        eax  
00000004  mov         dword ptr [ebp-4],ecx 
00000007  cmp         dword ptr ds:[009185C8h],0 
0000000e  je          00000015 
00000010  call        79469149 
00000015  cmp         dword ptr [ebp-4],64h 
00000019  jle         00000024 
   {
  return true;
0000001b  mov         eax,1 
00000020  mov         esp,ebp 
00000022  pop         ebp  
00000023  ret              
   }

   return false;
00000024  xor         eax,eax 
00000026  mov         esp,ebp 
00000028  pop         ebp  
00000029  ret              
            }

 static bool F2 (int condition)
 {
   if (condition > 100)
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        eax  
00000004  mov         dword ptr [ebp-4],ecx 
00000007  cmp         dword ptr ds:[009185C8h],0 
0000000e  je          00000015 
00000010  call        79469109 
00000015  cmp         dword ptr [ebp-4],64h 
00000019  jle         00000024 
   {
  return true;
0000001b  mov         eax,1 
00000020  mov         esp,ebp 
00000022  pop         ebp  
00000023  ret              
   }
   else
   {
  return false;
00000024  xor         eax,eax 
00000026  mov         esp,ebp 
00000028  pop         ebp  
00000029  ret              
            }

Which shows the two version produce the exact same code, as you would hope for. I also tried a third option:

 static bool F3 (int condition)
 {
   return condition > 100;
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        eax  
00000004  mov         dword ptr [ebp-4],ecx 
00000007  cmp         dword ptr ds:[009185C8h],0 
0000000e  je          00000015 
00000010  call        794690C9 
00000015  cmp         dword ptr [ebp-4],64h 
00000019  setg        al   
0000001c  movzx       eax,al 
0000001f  mov         esp,ebp 
00000021  pop         ebp  
00000022  ret              
            }

which is far more efficient as it never branches (and branches are usually bad!).

Skizz

EDIT

Actually, the best way to find out which is more efficient is to profile the code, not look at the assembler.

Also, the code it's produced is quite unusual. The push eax / mov [],ecx bit is the same, surely, as a single push ecx. Also, it passes by register then stores the value on the stack. I wonder if running the code in the debugger to look at the assembler is changing the way the code is generated.

Answer 6

You could discover this for yourself, by creating a test project with these two variations in it. Then, open the project in ildsam or Reflector to see the disassembly. You'll know exactly what's going on then.

Answer 7

I would be very surprised if there were a performance hit and the code suggests that there isn't.

After many years of trying to figure out legacy code in which multiple coders have tried to optimise expressions at the editor and have produced amazingly impenetrable code, I can only say that you should write what makes sense and expresses what you want in the simplest and clearest way.

All of the code snippets are easy to figure out because they are small but imagine the logic spread out over several pages ...