2012-07-05 6 views
4

Мне интересно, вложен ли, если лучше, чем инструкция AND. У меня есть цикл, который идет так много раз, поэтому я думаю о более быстром выполнении. Ниже приведен код, который имеет такую ​​же логику с моим кодом. Вложенный оператор if находится внутри цикла.Замена вложенного, если заявление с AND

for (int i = 0; i < array.length; i++) 
    { 
     // do stuff 
     if (x == 5) 
     { 
     if (y == 3) 
     { 
      // do stuff 
     } 
     } 
    } 

Будет ли мой код быстрее с существенной разницей, если я заменю вложенный, если с этим И ЗАЯВЛЕНИЕМ?

 if ((x == 5) && (y == 3)) 
      // do stuff 

Я прочитал это link, но я не нашел ответа. Я студент и все еще учился, спасибо за все отзывы!

ответ

3

.NET будет остановить проверку, если в первой части условного является ложным, поэтому не будет разницы в производительности между ними.

+0

делает ли эта логика и в заявлении AND тоже? – blenzcoffee

+0

Вот что я имел в виду. В выражении и, если первая половина ложна, она не будет проверять вторую половину. – Tyrsius

+1

Это называется короткое замыкание и все возможные замыкания логических операторов, когда это возможно, то есть, если они знают, что результат * должен * быть истинным/ложным, они немедленно прекращают выполнение любых других операторов, поскольку они не могут повлиять на результат. – Servy

9

Нет, у него не будет существенной разницы в производительности, , но может быть разница в читаемости.

Оба из них будет генерировать те же IL при компиляции с оптимизацией/выпуском (Испытано с LINQPad):

IL_0000: ldc.i4.5  
IL_0001: stloc.0  
IL_0002: ldc.i4.s 0A 
IL_0004: stloc.1  
IL_0005: ldloc.0  
IL_0006: ldc.i4.5  
IL_0007: bne.un.s IL_000D 
IL_0009: ldloc.1  
IL_000A: ldc.i4.3  
IL_000B: pop   

Даже без оптимизации разница является не столь существенным:

Вложенных заявления:

IL_0001: ldc.i4.5  
IL_0002: stloc.0  
IL_0003: ldc.i4.s 0A 
IL_0005: stloc.1  
IL_0006: ldloc.0  
IL_0007: ldc.i4.5  
IL_0008: ceq   
IL_000A: ldc.i4.0  
IL_000B: ceq   
IL_000D: stloc.2  
IL_000E: ldloc.2  
IL_000F: brtrue.s IL_0020 
IL_0011: nop   
IL_0012: ldloc.1  
IL_0013: ldc.i4.3  
IL_0014: ceq   
IL_0016: ldc.i4.0  
IL_0017: ceq   
IL_0019: stloc.2  
IL_001A: ldloc.2  
IL_001B: brtrue.s IL_001F 
IL_001D: nop   
IL_001E: nop 

Не вложенный stat ements:

IL_0001: ldc.i4.5  
IL_0002: stloc.0  
IL_0003: ldc.i4.s 0A 
IL_0005: stloc.1  
IL_0006: ldloc.0  
IL_0007: ldc.i4.5  
IL_0008: bne.un.s IL_0013 
IL_000A: ldloc.1  
IL_000B: ldc.i4.3  
IL_000C: ceq   
IL_000E: ldc.i4.0  
IL_000F: ceq   
IL_0011: br.s  IL_0014 
IL_0013: ldc.i4.1  
IL_0014: nop   
IL_0015: stloc.2  
IL_0016: ldloc.2  
IL_0017: brtrue.s IL_001B 
IL_0019: nop 
+1

«но по удобочитаемости»? :) – Almo

+0

@Almo, Имея вложенные if-утверждения, когда вам это не нужно, вызывать любое из них менее читаемым, но это субъективно (возможно) :) –

+2

Я согласен с вами, но фраза «но по ее удобочитаемости» Не имеет никакого смысла.Это иронично, поскольку он комментирует читаемость и сам по себе не читаем. :) – Almo

3

Нет, не будет никакой разницы между ними. Тем не менее, и делает меньше строк и более удобным для чтения (если вы не имеете, что многие условия)

Есть случаи, когда if s лучше и чувствовать себя более естественно, один общий пример заключается в следующем:

String s=//... 
if(s==null)return; 
if(s.Length > 0) //do something 

С, а это может быть заменен:

if ((s!=null) && (s.Length > 0)) //Dosomething 

Многие разработчики делают эту ошибку:

if ((s.Length > 0) && (s!=null)) //Dosomething 

Что будет в конечном итоге в нуле эталонного исключения

Как вы можете видеть, это более естественно думать, делать проверку нулевой первой при использовании отдельного if сек

+0

Иногда даже лучше использовать XOR - но он не подлежит повторному использованию ... – Jasper

+0

Истинный :), но читаемость имеет приоритет – GETah

1

В скомпилированном коде нет причин, по которым скорости должны быть разными, они будут переведены точно в один и тот же код сборки. Я определенно согласен с коэффициентом читаемости, а также сократит продолжительность вашего класса.