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

    if ( n_args >= 0 && n_args <= 2 )
        return true;

    switch ( n_args ) {
        default:
            fprintf( stderr, "error: args must be 0-2\n" );
            return false;
        case 0:
            // ...

sebelum kes pertama, contohnya:

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

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

pengisytiharan sebelum kes pertama, contohnya:

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

tidak memulakan pembolehubah seperti:

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

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.

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

    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!