Tukar Kenyataan Keanehan

pengenalan

Tatabahasa untuk pernyataan suis dalam C ialah:

        switch ( expression ) statement

C++ mewarisi suis C dan menambahkan keupayaan untuk menambah pernyataan init pilihan, tetapi itu bukan perkara utama untuk artikel ini.

Perhatikan apa yang tidak di sana: tiada sebutan sama ada kes atau lalai. Itu dinyatakan di tempat lain dalam tatabahasa. Ini bermakna ketepatan pernyataan suis dikuatkuasakan semantik dan bukannya sintaktik. Akibat daripada ini ialah kenyataan:

1. Boleh mana-mana pernyataan.
2. Dilayan tepat sama seperti mana-mana kenyataan lain.
3. Mungkin juga mengandungi sifar atau lebih label kes dan paling banyak satu label lalai.

Jatuh-Melalui

Salah satu ciri kontroversi C ialah, dalam pernyataan suis, kes "jatuh" kepada kes seterusnya (jika ada). Contohnya, diberi nilai 'a' untuk pembolehubah c, kod seperti:

switch ( c ) {
    case 'a':
        printf( "apple\n" );
    case 'b':
        printf( "banana\n" );
}

akan mencetak epal dan pisang kerana selepas memadankan 'a' dan mencetak epal, pelaksanaan hanya "melepasi" ke dalam bekas 'b'. Ini adalah hasil ganjil akibat #2 di atas kerana, di luar suis, pernyataan berturut-turut secara semula jadi "jatuh" dari satu ke yang seterusnya. Di dalam suis antara kes, ini bukan perkara yang anda mahukan pada kebanyakan masa, jadi anda boleh menggunakan rehat (atau teruskan jika dalam gelung, kembali atau goto).

Kebanyakan penyusun akan membenarkan anda meminta untuk diberi amaran apabila kod jatuh ke kes seterusnya. Mulai C23 atau C++17, anda boleh memasukkan atribut [[fallthrough]] untuk memberitahu pengkompil bahawa fall-through adalah disengajakan dan bukan untuk memberi amaran kepada anda:

switch ( how_good ) {
    case VERY_GOOD:
        printf( "very " );
        [[fallthrough]];
    case GOOD:
        printf( "good\n" );
        break;
}

Mungkin contoh yang paling terkenal tentang kejatuhan berguna ialah peranti Duff. Anda boleh membaca butirannya di sana, tetapi intinya ialah kod itu seperti (ditulis semula dalam C moden):

void send( short *to, short const *from, size_t count ) {
    size_t 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 );
    }
}

adalah sah sepenuhnya akibat daripada akibat #3, iaitu hakikat bahawa gelung do berada di dalam suis membenarkan sebarang pernyataan mempunyai label kes.

Kenyataan Tunggal

Dengan suis, penyataan selalunya merupakan penyataan-kompaun, iaitu urutan pernyataan yang disertakan dalam {}, tetapi ia boleh menjadi tunggal kenyataan:

bool check_n_args( int n_args ) {
    switch ( n_args )              // no { here
        case 0:
        case 1:
        case 2:
            return true;
                                   // no } here
    fprintf( stderr, "error: args must be 0-2\n" );
    return false;
}

Memandangkan hanya terdapat satu pernyataan pulangan benar, {} tidak diperlukan kerana ia tidak diperlukan selepas jika, lakukan, jika tidak, untuk atau sementara sama ada.

Selain daripada fakta bahawa perkara di atas adalah cara penulisan alternatif:

    if ( n_args >= 0 && n_args (kecuali ungkapan itu dinilai sekali sahaja) tidak ada sebab yang sah untuk menggunakan satu pernyataan dengan suis, jadi saya tidak akan mengesyorkan melakukannya.  Ini hanyalah hasil ganjil akibat #1 di atas.<p>

</p>
  
  
  lalai Tidak Terakhir
<h2>

</h2>Apabila suis mempunyai lalai, ia sentiasa terakhir, tetapi ia sebenarnya boleh berada di mana-mana sahaja dalam suis:<p>
<br>

</p>



<pre class="brush:php;toolbar:false">    switch ( n_args ) {
        default:
            fprintf( stderr, "error: args must be 0-2\n" );
            return false;
        case 0:
            // ...

Dari segi prestasi, kedudukan lalai (atau memang susunan kes) tidak penting. Satu-satunya sebab teknikal untuk tidak mempunyai lalai terakhir adalah jika anda ingin melaksanakan kejatuhan ke dalam kes seterusnya. Sebarang sebab lain adalah gaya semata-mata, mis., anda mahu mengendalikan kes biasa dahulu diikuti dengan kes khas.

Kenyataan Sebelum Kes Pertama

Pernyataan juga mungkin

sebelum kes pertama, contohnya:

switch ( n_args ) {
        printf( "never executed\n" );
    case 0:
        // ...

Pernyataan sedemikian

tidak pernah dilaksanakan. Kebanyakan penyusun akan memberi amaran tentang perkara ini. Setahu saya, tiada sebab untuk mempunyai kenyataan sebelum kes pertama.

Walau bagaimanapun, adalah sedikit berguna untuk mempunyai

pengisytiharan sebelum kes pertama, contohnya:

switch ( n_args ) {
        int i;
    case 0:
        i = f();
        // ...
        break;
    case 1:
        i = g();
        // ...
        break;
}

Ini berguna sedikit apabila pembolehubah digunakan hanya dalam skop suis oleh satu atau lebih kes. Ambil perhatian bahawa anda seharusnya

tidak memulakan pembolehubah seperti:

switch ( n_args ) {
        int i = 0;  // WRONG: do _not_ initialize!
    // ...

kerana, walaupun pembolehubah

diisytiharkan, kod permulaannya tidak pernah dilaksanakan (sama seperti printf() dalam contoh sebelumnya tidak pernah dilaksanakan), jadi kod itu menipu. Sebaliknya, anda mesti memulakan pembolehubah sedemikian dalam setiap kes yang menggunakannya.

Walaupun pengisytiharan mudah (tanpa permulaan) bukan kod boleh laku, sesetengah pengkompil masih akan (tersalah, IMHO) memberi amaran tentangnya. Oleh itu, pengisytiharan sedemikian tidak berguna.

Jika anda benar-benar mahukan pengisytiharan hanya dalam skop suis, anda boleh sama ada meletakkannya dalam kes pertama atau hanya dalam kes yang menggunakannya. Walau bagaimanapun, sebelum C23, pengisytiharan serta-merta selepas label tidak dibenarkan:

switch ( n_args ) {
    case 0:
        int i;       // error (pre-C23)
        // ...

Untuk mengatasi sekatan itu, anda boleh menambah {} untuk kes:

    case 0: {
        int i;       // OK now (all C versions)
        // ...
    }

A break-able Block

If you have a long block of code that you want to jump to the end of, there are a few ways to do it:

1. A sequence of if-else statements; or;
2. A sequence of if-goto statements; or;
3. A do { ... } while (0) statement with breaks.

Each has its trade-offs. Another way would be:

#define BLOCK  switch (0) default:

void f() {
    BLOCK {
        // ...
        if ( condition_1 )
            break;
        // ... lots more code ...
    }

    // "break" above jumps here

Hence, it’s most similar to do { ... } while (0), but without having to put the while (0) at the end.

Conclusion

The apparent simplicity of the switch statement in C (and C++) is deceptive in that it allows several odd ways to write code using them, some useful, some not. The most useful is Duff’s device for loop unrolling.

Atas ialah kandungan terperinci Tukar Kenyataan Keanehan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!