Mengapa pernyataan peralihan dirancang untuk membutuhkan istirahat?

Diberikan pernyataan beralih sederhana

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

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

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

Tidak adanya pernyataan istirahat dalam kasus 2, menyiratkan bahwa eksekusi akan berlanjut di dalam kode untuk kasus 3. Ini bukan kecelakaan; itu dirancang seperti itu. Mengapa keputusan ini dibuat? Apa manfaatnya dari ini vs memiliki semantic break otomatis untuk blok? Apa alasannya?

Banyak jawaban tampaknya berfokus pada kemampuan untuk jatuh sebagai alasan untuk membutuhkannyabreak pernyataan itu.

Saya percaya itu hanya kesalahan, karena sebagian besar karena ketika C dirancang, tidak ada banyak pengalaman dengan bagaimana konstruksi ini akan digunakan.

Peter Van der Linden membuat kasus ini dalam bukunya "Expert C Programming":

Kami menganalisis sumber kompiler Sun C untuk melihat seberapa sering jatuh standar digunakan. Ujung depan kompilator Sun ANSI C memiliki 244 pernyataan switch, yang masing-masing memiliki rata-rata tujuh kasus. Kejatuhan terjadi hanya dalam 3% dari semua kasus ini.

Dengan kata lain, perilaku saklar normal salah 97% dari waktu. Bukan hanya di kompiler - sebaliknya, di mana fall through digunakan dalam analisis ini, itu sering untuk situasi yang terjadi lebih sering di kompiler daripada di perangkat lunak lain, misalnya, ketika mengkompilasi operator yang dapat memiliki satu atau dua operan :

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

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

Kasus jatuh begitu banyak diakui sebagai cacat sehingga bahkan ada konvensi komentar khusus, yang ditunjukkan di atas, yang memberitahu serat "ini benar-benar salah satu dari 3% kasus di mana jatuh diinginkan."

Saya pikir itu ide yang baik untuk C # untuk meminta pernyataan lompatan eksplisit di akhir setiap blok kasus (sementara masih memungkinkan beberapa label kasus ditumpuk - selama hanya ada satu blok pernyataan). Dalam C # Anda masih dapat memiliki satu kasus jatuh ke yang lain - Anda hanya perlu membuat jatuh melalui eksplisit dengan melompat ke kasus berikutnya menggunakangoto .

Sayang sekali Java tidak mengambil kesempatan untuk istirahat dari semantik C.

Dalam banyak hal c hanyalah antarmuka yang bersih untuk idiom perakitan standar. Ketika menulis tabel kontrol aliran didorong lompat, programmer memiliki pilihan jatuh melalui atau melompat keluar dari "struktur kontrol", dan lompat keluar membutuhkan instruksi eksplisit.

Jadi, c melakukan hal yang sama ...

Untuk mengimplementasikan perangkat Duff, jelas:

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);
    }
}

Jika case dirancang untuk pecah secara implisit maka Anda tidak bisa gagal.

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

Jika saklar dirancang untuk keluar secara implisit setelah setiap kasus Anda tidak akan punya pilihan tentang hal itu. Struktur sakelar didesain sedemikian rupa agar lebih fleksibel.

Pernyataan kasus dalam pernyataan switch hanyalah label.

Ketika Anda mengaktifkan nilai, pernyataan switch pada dasarnya melakukan kebohongan ke label dengan nilai yang cocok.

Ini berarti bahwa istirahat diperlukan untuk menghindari melewati kode di bawah label berikutnya.

Adapun alasan mengapa itu diterapkan dengan cara ini - sifat fall-through dari pernyataan switch dapat berguna dalam beberapa skenario. Sebagai contoh:

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;

Untuk mengizinkan hal-hal seperti:

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 */
}

Pikirkan casekata kunci sebagai gotolabel dan itu jauh lebih alami.

Ini menghilangkan duplikasi kode ketika beberapa kasus perlu mengeksekusi kode yang sama (atau kode yang sama secara berurutan).

Karena pada tingkat bahasa assembly, tidak masalah apakah Anda menerobos masing-masing atau tidak ada nol overhead untuk kasus jatuh, jadi mengapa tidak mengizinkan mereka karena mereka menawarkan keuntungan yang signifikan dalam kasus-kasus tertentu.

Saya kebetulan berlari ke dalam kasus penetapan nilai dalam vektor ke struct: itu harus dilakukan sedemikian rupa sehingga jika vektor data lebih pendek dari jumlah anggota data dalam struct, sisa anggota akan tetap di nilai default mereka. Dalam hal menghilangkan breakitu cukup berguna.

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);
}

Seperti yang ditentukan di sini, ini memungkinkan satu blok kode berfungsi untuk banyak kasus. Ini seharusnya menjadi kejadian yang lebih umum untuk pernyataan switch Anda daripada "blok kode per kasus" yang Anda tentukan dalam contoh Anda.

Jika Anda memiliki blok kode per kasus tanpa jatuh, mungkin Anda harus mempertimbangkan untuk menggunakan blok if-elseif-else, karena itu akan tampak lebih tepat.