Switch deyimi neden bir mola gerektirecek şekilde tasarlandı?

Basit bir anahtar bildirimi verildi

switch (int)
{
    case 1 :
    {
        printf("1\n");
        break;
    }

    case 2 : 
    {
        printf("2\n");
    }

    case 3 : 
    {
        printf("3\n");
    }
}

Durum 2'de bir kesme ifadesinin olmaması, yürütmenin durum 3 için kod içinde devam edeceğini ima eder. Bu bir kaza değildir; bu şekilde tasarlandı. Bu kararlar neden verildi? Bu, bloklar için otomatik bir anlam semantikine karşı ne fayda sağlar? Gerekçe neydi?

Birçok cevap , ifadeyi gerektirme nedeni olarak düşme yeteneğine odaklanıyor gibi görünmektedir break.

Bunun sadece bir hata olduğuna inanıyorum, çünkü C tasarlandığında bu yapıların nasıl kullanılacağı konusunda neredeyse hiç deneyim yoktu.

Peter Van der Linden "Uzman C Programlama" kitabında dava açıyor:

Varsayılan düşüşün ne sıklıkta kullanıldığını görmek için Sun C derleyici kaynaklarını analiz ettik. Sun ANSI C derleyici ön ucunda her biri ortalama yedi kasa bulunan 244 anahtar ifadesi bulunur. Düşme, tüm bu vakaların sadece% 3'ünde görülür.

Başka bir deyişle, normal anahtar davranışı zamanın% 97'sinde yanlıştır . Sadece bir derleyicide değil - aksine, bu analizde düşüşün kullanıldığı yerlerde, bir derleyicide diğer yazılımlardan daha sık meydana gelen durumlar için, örneğin bir veya iki işlenen içerebilen operatörleri derlerken. :

switch (operator->num_of_operands) {
    case 2: process_operand( operator->operand_2);
              /* FALLTHRU */

    case 1: process_operand( operator->operand_1);
    break;
}

Vaka düşmesi o kadar geniş bir kusur olarak kabul edilir ki, yukarıda gösterilen özel bir yorum sözleşmesi bile vardır, bu da tiftik "bunun gerçekten düşmenin istendiği vakaların% 3'ünden biri olduğunu" söyler.

(Sadece tek bir blok bloğu olduğu sürece) hala birden çok vaka etiketlerinin yığılmasına izin verirken (her durumda bloğunun sonunda açık bir atlama ifadesi gerektiren C # için iyi bir fikir olduğunu düşünüyorum. C # 'da hala bir vakanın diğerine düşmesini sağlayabilirsiniz - sadece düşme yoluyla düşmeyi bir sonraki vakaya atlayarakgoto .

Java'nın C semantiğinden kopma fırsatını almadığı çok kötü.

Birçok yönden c, standart montaj deyimleri için temiz bir arayüzdür. Atlama tablosu tahrikli akış kontrolü yazarken, programcı "kontrol yapısı" ndan düşme veya atlamadan seçim yapma seçeneğine sahiptir ve bir atlama, açık bir talimat gerektirir.

Yani, c de aynı şeyi yapıyor ...

Duff'ın cihazını uygulamak için açıkçası:

dsend(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

Olgular örtük olarak kırılmak üzere tasarlanmış olsaydı o zaman atılım olamazdı.

case 0:
case 1:
case 2:
    // all do the same thing.
    break;
case 3:
case 4:
    // do something different.
    break;
default:
    // something else entirely.

Anahtar her durumdan sonra örtük olarak kırılmak üzere tasarlanmış olsaydı, bu konuda bir seçiminiz olmazdı. Şalt kutusu yapısı daha esnek olacak şekilde tasarlanmıştır.

Bir switch deyimindeki case deyimleri yalnızca etiketlerdir.

Bir değeri açtığınızda, switch ifadesi esasen etikete eşleşen değerle bir goto yapar .

Bu, bir sonraki etiketin altındaki koda geçmemek için kopmanın gerekli olduğu anlamına gelir.

Nedenle gelince neden sonbahar-through switch ifadesinden doğada bazı senaryolarda yararlı olabilir - bu şekilde hayata geçirildi. Örneğin:

case optionA:
    // optionA needs to do its own thing, and also B's thing.
    // Fall-through to optionB afterwards.
    // Its behaviour is a superset of B's.
case optionB:
    // optionB needs to do its own thing
    // Its behaviour is a subset of A's.
    break;
case optionC:
    // optionC is quite independent so it does its own thing.
    break;

Gibi şeylere izin vermek için:

switch(foo) {
case 1:
    /* stuff for case 1 only */
    if (0) {
case 2:
    /* stuff for case 2 only */
    }
    /* stuff for cases 1 and 2 */
case 3:
    /* stuff for cases 1, 2, and 3 */
}

caseAnahtar kelimeyi bir gotoetiket olarak düşünün ve çok daha doğal bir şekilde geliyor.

Birkaç durumun aynı kodu (veya sırayla aynı kodu) yürütmesi gerektiğinde kod çoğaltmasını ortadan kaldırır.

Montaj dili düzeyinde, her biri arasında kırılıp kırılmayacağınız umurumda değil, yine de vakalar için düşme için sıfır ek yük var, bu yüzden bazı durumlarda önemli avantajlar sundukları için neden izin vermiyorsunuz?

Vektörlerde yapılara değer atama davasına koştum: veri vektörü yapıdaki veri üyelerinin sayısından daha kısa olursa, üyelerin geri kalanı içinde kalacaktı. varsayılan değerleri. Bu durumda ihmal breakoldukça faydalı olmuştur.

switch (nShorts)
{
case 4: frame.leadV1    = shortArray[3];
case 3: frame.leadIII   = shortArray[2];
case 2: frame.leadII    = shortArray[1];
case 1: frame.leadI     = shortArray[0]; break;
default: TS_ASSERT(false);
}

Burada belirtildiği gibi, tek bir kod bloğunun birden fazla durumda çalışmasına izin vermek. Bu olmalı , anahtar ifadeleriniz için, örneğinizde belirttiğiniz "vaka başına kod bloğu" ndan daha yaygın bir durum .

Düşme olmadan vaka başına bir kod bloğunuz varsa, belki de daha uygun göründüğü için if-elseif-else bloğunu kullanmayı düşünmelisiniz.