İf-else deyimini değiştirmenin avantajı

Yaklaşık 10 tanesinin beklenen bir eylemi olduğu (şu anda aynı eylemdir) 30 numaralandırma için switchbir ififade kullanmak yerine ifade kullanmak için en iyi uygulama nedir unsigned? Performans ve alan dikkate alınmalıdır, ancak kritik değildir. Parçacığı soyutladım, bu yüzden adlandırma kuralları için benden nefret etmeyin.

switch Beyan:

// numError is an error enumeration type, with 0 being the non-error case
// fire_special_event() is a stub method for the shared processing

switch (numError)
{  
  case ERROR_01 :  // intentional fall-through
  case ERROR_07 :  // intentional fall-through
  case ERROR_0A :  // intentional fall-through
  case ERROR_10 :  // intentional fall-through
  case ERROR_15 :  // intentional fall-through
  case ERROR_16 :  // intentional fall-through
  case ERROR_20 :
  {
     fire_special_event();
  }
  break;

  default:
  {
    // error codes that require no additional action
  }
  break;       
}

if Beyan:

if ((ERROR_01 == numError)  ||
    (ERROR_07 == numError)  ||
    (ERROR_0A == numError)  || 
    (ERROR_10 == numError)  ||
    (ERROR_15 == numError)  ||
    (ERROR_16 == numError)  ||
    (ERROR_20 == numError))
{
  fire_special_event();
}

Anahtarı kullanın.

En kötü durumda derleyici if-else zinciri ile aynı kodu üretir, böylece hiçbir şey kaybetmezsiniz. Şüpheniz varsa, en yaygın vakaları önce switch deyimine koyun.

En iyi durumda, optimize edici kodu oluşturmak için daha iyi bir yol bulabilir. Bir derleyicinin yaptığı ortak şey, ikili bir karar ağacı oluşturmak (karşılaştırmaları ve ortalama durumda atlar) veya sadece bir atlama tablosu oluşturmaktır (hiç karşılaştırılmadan çalışır).

Örneğinizde sağladığınız özel durum için en açık kod muhtemelen:

if (RequiresSpecialEvent(numError))
    fire_special_event();

Açıkçası bu sadece sorunu kodun farklı bir alanına taşır, ancak şimdi bu testi tekrar kullanma şansına sahipsiniz. Ayrıca nasıl çözüleceğine dair daha fazla seçeneğiniz var. Std :: set kullanabilirsiniz, örneğin:

bool RequiresSpecialEvent(int numError)
{
    return specialSet.find(numError) != specialSet.end();
}

Bu, bir seçenek olduğunu, bu RequespecialEvent en iyi uygulaması olduğunu önermiyorum. Yine de, bir anahtar veya if-else zinciri ya da bir arama tablosu ya da değer üzerinde herhangi bir bit manipülasyonu kullanabilirsiniz. Karar verme süreciniz ne kadar belirsiz olursa, yalıtılmış bir işleve sahip olmanızdan o kadar çok değer elde edersiniz.

Anahtar daha hızlıdır.

Bir döngü içinde 30 farklı değer olup olmadığını deneyin ve anahtarın ne kadar hızlı olduğunu görmek için anahtarı kullanarak aynı kodla karşılaştırın.

Şimdi, anahtarın gerçek bir sorunu var : Anahtar derleme zamanında her durumdaki değerleri bilmelidir. Bu şu kod anlamına gelir:

// WON'T COMPILE
extern const int MY_VALUE ;

void doSomething(const int p_iValue)
{
    switch(p_iValue)
    {
       case MY_VALUE : /* do something */ ; break ;
       default : /* do something else */ ; break ;
    }
}

derlenmeyecek.

Çoğu kişi tanımları (Aargh!) Kullanır ve diğerleri aynı derleme birimindeki sabit değişkenleri bildirir ve tanımlar. Örneğin:

// WILL COMPILE
const int MY_VALUE = 25 ;

void doSomething(const int p_iValue)
{
    switch(p_iValue)
    {
       case MY_VALUE : /* do something */ ; break ;
       default : /* do something else */ ; break ;
    }
}

Sonuç olarak, geliştirici "hız + netlik" ile "kod bağlantısı" arasında seçim yapmalıdır.

(Bir anahtarın cehennem gibi kafa karıştırıcı olması için yazılamaz ... Şu anda gördüğüm çoğu anahtar bu "kafa karıştırıcı" kategoriden "... Ama bu başka bir hikaye ...)

2008-09-21'i düzenleyin:

bk1e şu yorumu ekledi: " Sabitleri bir başlık dosyasında numaralandırmalar olarak tanımlamak bunu işlemenin başka bir yoludur".

Tabiki öyle.

Harici tipin noktası değeri kaynaktan ayırmaktı. Bu değeri bir makro, basit bir int int bildirimi olarak veya hatta bir numaralandırma olarak tanımlamak, değeri satır içine almanın yan etkisine sahiptir. Bu nedenle, tanım, enum değeri veya sabit int değer değişirse, yeniden derleme gerekli olacaktır. Harici beyan, değer değişikliği durumunda yeniden derlemeye gerek olmadığı anlamına gelir, ancak diğer yandan anahtarın kullanılmasını imkansız hale getirir. Anahtar kullanma sonucu , anahtar kodu ile vaka olarak kullanılan değişkenler arasındaki bağlantıyı artıracaktır . Tamam olduğunda, anahtarı kullanın. Değilse, o zaman sürpriz olmaz.

.

2013-01-15'i düzenleyin:

Vlad Lazarenko cevabımı yorumladı ve bir anahtarın oluşturduğu montaj kodu üzerine derinlemesine çalışmasına bir bağlantı verdi. Çok aydınlatıcı: http://lazarenko.me/switch/

Derleyici zaten optimize edecek - en okunabilir olduğu için anahtara gidin.

Anahtar yalnızca okunabilirlik içinse. Bence dev ifadelerin bakımı daha zor ve okunması daha zor.

ERROR_01 : // kasıtlı düşme

veya

(ERROR_01 == numError) ||

İkincisi daha fazla hataya eğilimlidir ve ilkinden daha fazla yazma ve biçimlendirme gerektirir.

Okunabilirlik kodu. Neyin daha iyi performans gösterdiğini bilmek istiyorsanız, optimizasyonlar ve derleyiciler değiştikçe bir profil oluşturucu kullanın ve performans sorunları nadiren insanların düşündükleri yerdir.

Anahtarı kullanın, bunun için ve programcıların beklediği şey budur.

Gereksiz vaka etiketlerini yerleştirirdim - sadece insanları rahat hissettirmek için, kuralların ne zaman / ne olduğunu dışarıda bırakmak için ne olduğunu hatırlamaya çalışıyordum.
Üzerinde çalışan bir sonraki programcının dil ayrıntıları hakkında gereksiz düşünmeler yapmasını istemezsiniz (birkaç ay içinde siz olabilirsiniz!)

Derleyiciler optimizasyonda gerçekten iyidir switch. Son gcc aynı zamanda bir grup koşulu optimize etmekte de iyidir.if .

Godbolt üzerinde bazı test senaryoları yaptım .

Ne zaman case değerleri birbirine yakın gruplanmış, gcc, çınlama ve icc bir değer özel olanlardan biri olup olmadığını kontrol etmek için bir bit eşlem kullanmak için tüm akıllı yeterlidir.

örneğin gcc 5.2-O3, ' switchyi (ve ifçok benzer bir şeyi) derler :

errhandler_switch(errtype):  # gcc 5.2 -O3
    cmpl    $32, %edi
    ja  .L5
    movabsq $4301325442, %rax   # highest set bit is bit 32 (the 33rd bit)
    btq %rdi, %rax
    jc  .L10
.L5:
    rep ret
.L10:
    jmp fire_special_event()

Bitmap'in hemen veri olduğuna dikkat edin, bu nedenle ona erişen herhangi bir veri önbelleği kaçırması veya bir atlama tablosu yoktur.

gcc 4.9.2-O3 switch, bir bitmap'i derler , ancak 1U<<errNumbermov / shift ile yapar . ifSürümü şube serisine derler .

errhandler_switch(errtype):  # gcc 4.9.2 -O3
    leal    -1(%rdi), %ecx
    cmpl    $31, %ecx    # cmpl $32, %edi  wouldn't have to wait an extra cycle for lea's output.
              # However, register read ports are limited on pre-SnB Intel
    ja  .L5
    movl    $1, %eax
    salq    %cl, %rax   # with -march=haswell, it will use BMI's shlx to avoid moving the shift count into ecx
    testl   $2150662721, %eax
    jne .L10
.L5:
    rep ret
.L10:
    jmp fire_special_event()

1'den errNumber( çıkarma leaişlemini bir hareketle birleştirmek için) nasıl çıkardığına dikkat edin. Bu, bitmap'i 32bit acil duruma sığdırır ve 64bit acil durumdan kaçınırmovabsq daha fazla talimat baytı alan .

Daha kısa (makine kodunda) bir dizi şöyle olur:

    cmpl    $32, %edi
    ja  .L5
    mov     $2150662721, %eax
    dec     %edi   # movabsq and btq is fewer instructions / fewer Intel uops, but this saves several bytes
    bt     %edi, %eax
    jc  fire_special_event
.L5:
    ret

(Kullanılamaması jc fire_special_eventher yerde mevcuttur ve bir derleyici hatasıdır .)

rep retAMD K8 ve K10'un (Buldozer öncesi) yararına şube hedeflerinde ve aşağıdaki koşullu dallarda kullanılır: `` ret ret` ne demektir? . Bu olmadan, şube tahmini bu eski CPU'larda da işe yaramaz.

bt(bit testi) register arg ile hızlıdır. Bir 1'i errNumberbitlerle sola kaydırma ve a yapma işini birleştirir test, ancak yine de 1 döngü gecikmesi ve sadece tek bir Intel uop'dur. CISC yolu semantiği nedeniyle bir bellek argümanıyla yavaştır: "bit dizesi" için bir bellek işleneni ile, test edilecek baytın adresi diğer argümana (8'e bölünür) dayalı olarak hesaplanır ve bellek işleneninin işaret ettiği 1, 2, 4 veya 8 bayt yığınla sınırlı değildir.

Gönderen Agner Fog'un talimat tabloları , değişken sayımı kaydırma talimatı bir daha yavaş btson Intel (2 UOPs yerine 1 ve Vardiyam ihtiyacı olduğunu her şeyi yapmaz) üzerinde.

Başka bir durum söz konusu olduğunda switch () 'in avantajları şunlardır: - 1. Anahtar, başka bir ifadeye göre çok daha verimlidir çünkü her bir durum, bireysel ifadenin doğru veya yanlış durum için kontrol edilmesi gereken başka bir durumdan farklı olarak önceki duruma bağlı değildir.

2. Hayır olduğunda. ifadesi tek bir ifade için değerlerden oluşuyorsa, switch case başka bir durumda daha esnektir çünkü aksi durumda yargılama yalnızca iki değere (yani true veya false) dayanır.

3. Anahtardaki değerler kullanıcı tanımlıyken, başka bir durumda ise değerler kısıtlamalara dayanır.

4. Hata durumunda, anahtardaki ifadeler kolayca çapraz kontrol edilebilir ve düzeltilebilir; bu, eğer başka bir ifadenin durumunda kontrol edilmesi nispeten güçtür.

5. Anahtar kutusu çok daha kompakt ve okunması ve anlaşılması kolaydır.

IMO, bu geçişin ne için yapıldığının mükemmel bir örneğidir.

Vakalarınızın gelecekte gruplanmış olması muhtemelse - birden fazla vaka bir sonuca karşılık geliyorsa - anahtarın okunması ve bakımı daha kolay olabilir.

Eşit derecede iyi çalışırlar. Modern bir derleyici göz önüne alındığında performans hemen hemen aynıdır.

Daha okunabilir ve daha esnek olduklarından, ifadelerin büyük / küçük harf ifadeleri yerine tercih edilmesini tercih ederim. "|| max <min" gibi sayısal eşitliğe dayanmayan başka koşullar ekleyebilirsiniz. Ancak burada yayınladığınız basit dava için, gerçekten önemli değil, sadece sizin için en okunabilir olanı yapın.

anahtar kesinlikle tercih edilir. Bir anahtarın vaka listesine bakmak ve ne yaptığını kesin olarak bilmek, uzun süre koşulunu okumaktan daha kolaydır.

Durumdaki tekrarlama ifgözler üzerinde zordur. Varsayalım ki bunlardan biri ==yazılmıştır !=; fark eder misin Ya da 'numError' örneğinin derlendiği 'nmuError' yazıldıysa hangisi derlendi?

Genellikle anahtar yerine polimorfizm kullanmayı tercih ederdim, ancak bağlamla ilgili daha fazla ayrıntı olmadan söylemek zor.

Performansa gelince, en iyi bahis, uygulamanızın performansını vahşi doğada beklediğinize benzer koşullarda ölçmek için bir profil oluşturucu kullanmaktır. Aksi takdirde, muhtemelen yanlış yerde ve yanlış şekilde optimizasyon yapıyorsunuzdur.

Anahtar çözümünün uygunluğuna katılıyorum, ancak IMO , anahtarı burada ele geçiriyorsunuz .
Anahtarın amacı , değere bağlı olarak farklı kullanımlara sahip olmaktır .
Algo'yu sözde kodda açıklamak zorunda olsaydın, bir if kullanacaksın, çünkü anlamsal olarak, işte budur: whatever_error bunu yaparsa ... Bir
gün kodunu her hata için belirli bir kod olacak şekilde değiştirmek istemiyorsan , Eğer kullanırdım .

Bazılarının aynı fikirde olmayacağından emin olsam da, açıklık ve kongre adına if ifadesini seçerdim. Sonuçta, ifbazı koşullar doğru bir şey yapmak istiyorsun ! Tek bir işlemle geçiş yapmak biraz ... gereksiz görünüyor.

SWITCH kullan diyebilirim. Bu şekilde sadece farklı sonuçlar uygulamanız gerekir. On özdeş vakanız varsayılanı kullanabilir. Bir değişiklik yapmanız gereken tek şey değişikliği açıkça uygulamaksa, varsayılanı düzenlemenize gerek yoktur. SWITCH'e vaka eklemek veya çıkarmak, IF ve ELSEIF'i düzenlemekten çok daha kolaydır.

switch(numerror){
    ERROR_20 : { fire_special_event(); } break;
    default : { null; } break;
}

Belki de durumunuzu (bu durumda numerror) bir olasılıklar listesine karşı test edin, belki de bir dizi, bu yüzden kesinlikle bir sonuç olmayacaksa ANAHTARINIZ bile kullanılmaz.

Sadece 30 hata koduna sahip olduğunuzu görünce, kendi atlama tablonuzu kodlayın, sonra derleyicinin doğru şeyi yapmasını ummak yerine tüm optimizasyon seçimlerini kendiniz yapın (atlama her zaman en hızlı olacaktır). Ayrıca kodu çok küçük hale getirir (atlama tablosunun statik bildirimi dışında). Ayrıca, yalnızca tablo verilerini doğrudan atarak, bir hata ayıklayıcı ile çalışma zamanında davranışı değiştirebilmenizin yan faydası vardır.

En iyi uygulamadan emin değilim, ancak anahtarı kullanırdım - ve sonra 'varsayılan' aracılığıyla kasıtlı düşmeyi yakalardım

Estetik olarak bu yaklaşımı destekleme eğilimindeyim.

unsigned int special_events[] = {
    ERROR_01,
    ERROR_07,
    ERROR_0A,
    ERROR_10,
    ERROR_15,
    ERROR_16,
    ERROR_20
 };
 int special_events_length = sizeof (special_events) / sizeof (unsigned int);

 void process_event(unsigned int numError) {
     for (int i = 0; i < special_events_length; i++) {
         if (numError == special_events[i]) {
             fire_special_event();
             break;
          }
     }
  }

Verileri biraz daha akıllı hale getirin, böylece mantığı biraz daha kalın hale getirelim.

Tuhaf göründüğünün farkındayım. İşte ilham (Python'da nasıl yapacağımdan):

special_events = [
    ERROR_01,
    ERROR_07,
    ERROR_0A,
    ERROR_10,
    ERROR_15,
    ERROR_16,
    ERROR_20,
    ]
def process_event(numError):
    if numError in special_events:
         fire_special_event()

while (true) != while (loop)

Muhtemelen birincisi derleyici tarafından optimize edilmiştir, bu da döngü sayısını arttırırken ikinci döngünün neden daha yavaş olduğunu açıklar.

Programı derlemek söz konusu olduğunda, herhangi bir fark olup olmadığını bilmiyorum. Ancak programın kendisi ve kodu olabildiğince basit tutmak, kişisel olarak ne yapmak istediğinize bağlı olduğunu düşünüyorum. else if else ifadelerinin avantajları var, bence:

bir değişkeni belirli aralıklarla test etmenize olanak tanır ve koşullu olarak (Standart Kütüphane veya Kişisel) işlevleri kullanabilirsiniz.

(misal:

`int a;
 cout<<"enter value:\n";
 cin>>a;

 if( a > 0 && a < 5)
   {
     cout<<"a is between 0, 5\n";

   }else if(a > 5 && a < 10)

     cout<<"a is between 5,10\n";

   }else{

       "a is not an integer, or is not in range 0,10\n";

Ancak, eğer başka durumlarda acele karmaşık ve dağınık (en iyi girişimlerinize rağmen) alabilirsiniz. Anahtar ifadeleri daha açık, daha temiz ve daha kolay okunur olma eğilimindedir; ancak yalnızca belirli değerlere karşı test yapmak için kullanılabilir (örnek:

`int a;
 cout<<"enter value:\n";
 cin>>a;

 switch(a)
 {
    case 0:
    case 1:
    case 2: 
    case 3:
    case 4:
    case 5:
        cout<<"a is between 0,5 and equals: "<<a<<"\n";
        break;
    //other case statements
    default:
        cout<<"a is not between the range or is not a good value\n"
        break;

Eğer if - else if - else ifadelerini tercih ederim, ama gerçekten size kalmış. İşlevleri koşul olarak kullanmak istiyorsanız veya bir aralığı, dizi veya vektöre karşı bir şey test etmek istiyorsanız ve / veya karmaşık iç içe geçme ile uğraşmak istemiyorsanız, eğer başka bloklar varsa If kullanmanızı öneririz. Tek değerlere karşı test etmek veya temiz ve okunması kolay bir blok istiyorsanız, switch () büyük / küçük harf bloklarını kullanmanızı tavsiye ederim.

Ben hız ve bellek kullanımı hakkında size söyleyecek kişi değilim, ancak bir anahtar ifadesine bakmak çok daha kolay anlaşılması çok daha büyük bir if ifadesi (özellikle 2-3 ay aşağı)

Eski olduğunu biliyorum ama

public class SwitchTest {
static final int max = 100000;

public static void main(String[] args) {

int counter1 = 0;
long start1 = 0l;
long total1 = 0l;

int counter2 = 0;
long start2 = 0l;
long total2 = 0l;
boolean loop = true;

start1 = System.currentTimeMillis();
while (true) {
  if (counter1 == max) {
    break;
  } else {
    counter1++;
  }
}
total1 = System.currentTimeMillis() - start1;

start2 = System.currentTimeMillis();
while (loop) {
  switch (counter2) {
    case max:
      loop = false;
      break;
    default:
      counter2++;
  }
}
total2 = System.currentTimeMillis() - start2;

System.out.println("While if/else: " + total1 + "ms");
System.out.println("Switch: " + total2 + "ms");
System.out.println("Max Loops: " + max);

System.exit(0);
}
}

Döngü sayısının değiştirilmesi çok değişir:

Eğer ise / else: 5ms Anahtar: 1ms Max Döngüler: 100000

Eğer ise / else: 5ms Anahtar: 3ms Max Döngüler: 1000000

Eğer ise / else: 5ms Anahtar: 14ms Max Döngü: 10000000

Eğer / else ise: 5ms Anahtar: 149ms Maksimum Döngü: 100000000

(isterseniz daha fazla ifade ekleyin)