Mengapa Dentang / LLVM memperingatkan saya tentang penggunaan default dalam pernyataan switch di mana semua kasus yang disebutkan dicakup?

Pertimbangkan pernyataan enum dan switch berikut:

typedef enum {
    MaskValueUno,
    MaskValueDos
} testingMask;

void myFunction(testingMask theMask) {
    switch (theMask) {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
        default: {} //deal with an unexpected or uninitialized value
    }
};

Saya seorang programmer Objective-C, tetapi saya telah menulis ini dalam C murni untuk audiens yang lebih luas.

Dentang / LLVM 4.1 dengan -Weverything memperingatkan saya di baris default:

Label default dalam sakelar yang mencakup semua nilai enumerasi

Sekarang, saya bisa melihat mengapa ini ada: di dunia yang sempurna, satu-satunya nilai yang masuk dalam argumen theMaskakan berada di enum, jadi tidak ada standar yang diperlukan. Tetapi bagaimana jika beberapa hack datang dan melempar int yang tidak diinisialisasi ke dalam fungsi saya yang cantik? Fungsi saya akan disediakan sebagai setetes di perpustakaan, dan saya tidak punya kendali atas apa yang bisa masuk ke sana. Menggunakan defaultadalah cara penanganan yang sangat rapi.

Mengapa para dewa LLVM menganggap perilaku ini tidak layak bagi perangkat infernal mereka? Haruskah saya mendahului ini dengan pernyataan if untuk memeriksa argumen?

Berikut adalah versi yang tidak mengalami masalah yang terkait dengan pelaporan, atau versi yang Anda jaga:

void myFunction(testingMask theMask) {
    assert(theMask == MaskValueUno || theMask == MaskValueDos);
    switch (theMask) {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
    }
}

Killian telah menjelaskan mengapa dentang memancarkan peringatan: jika Anda memperpanjang enum, Anda akan jatuh ke dalam kasus default yang mungkin bukan yang Anda inginkan. Yang benar untuk dilakukan adalah menghapus case default dan mendapatkan peringatan untuk kondisi yang tidak tertangani .

Sekarang Anda khawatir seseorang dapat memanggil fungsi Anda dengan nilai di luar pencacahan. Kedengarannya seperti gagal memenuhi persyaratan fungsi: itu didokumentasikan untuk mengharapkan nilai dari testingMaskenumerasi tetapi programmer telah melewati sesuatu yang lain. Jadi buatlah kesalahan programmer menggunakan assert()(atau NSCAssert()seperti yang Anda katakan Anda menggunakan Objective-C). Buat program Anda macet dengan pesan yang menjelaskan bahwa programmer salah melakukannya, jika programmer salah.

Memiliki defaultlabel di sini adalah indikator bahwa Anda bingung tentang apa yang Anda harapkan. Karena Anda telah kehabisan semua enumnilai yang mungkin secara eksplisit, maka nilai defaulttersebut tidak dapat dieksekusi, dan Anda tidak memerlukannya untuk menjaga terhadap perubahan di masa mendatang, karena jika Anda memperpanjang enum, maka konstruk tersebut sudah akan menghasilkan peringatan.

Jadi, kompiler memperhatikan bahwa Anda telah membahas semua pangkalan tetapi tampaknya berpikir bahwa Anda belum melakukannya, dan itu selalu merupakan pertanda buruk. Dengan mengambil upaya minimal untuk mengubah switchke bentuk yang diharapkan, Anda menunjukkan kepada kompiler bahwa apa yang tampaknya Anda lakukan adalah apa yang sebenarnya Anda lakukan, dan Anda tahu itu.

Dentang bingung, memiliki pernyataan default ada praktik baik-baik saja, itu dikenal sebagai pemrograman defensif dan dianggap praktik pemrograman yang baik (1). Ini digunakan banyak dalam sistem mission-critical, meskipun mungkin tidak dalam pemrograman desktop.

Tujuan pemrograman defensif adalah untuk menangkap kesalahan tak terduga yang secara teori tidak akan pernah terjadi. Kesalahan yang tidak terduga seperti itu belum tentu programmer memberikan fungsi input yang salah, atau bahkan "peretas jahat". Kemungkinan besar, itu bisa disebabkan oleh variabel yang korup: buffer overflows, stack overflow, runaway code, dan bug serupa yang tidak terkait dengan fungsi Anda dapat menyebabkan hal ini. Dan dalam hal sistem tertanam, variabel mungkin dapat berubah karena EMI, terutama jika Anda menggunakan sirkuit RAM eksternal.

Adapun apa yang ditulis di dalam pernyataan default ... jika Anda mencurigai bahwa program tersebut telah rusak setelah Anda berakhir di sana, maka Anda memerlukan semacam penanganan kesalahan. Dalam banyak kasus Anda mungkin hanya dapat menambahkan pernyataan kosong dengan komentar: "tak terduga tetapi tidak masalah" dll, untuk menunjukkan bahwa Anda telah memikirkan situasi yang tidak mungkin.

(1) MISRA-C: 2004 15.3.

Lebih baik lagi:

typedef enum {
    MaskValueUno,
    MaskValueDos,

    MaskValue_count
} testingMask;

void myFunction(testingMask theMask) {
    assert(theMask >= 0 && theMask<MaskValue_count);
    switch theMask {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
    }
};

Ini lebih rentan kesalahan saat menambahkan item ke enum. Anda dapat melewati tes untuk> = 0 jika Anda membuat nilai enum Anda tidak ditandatangani. Metode ini hanya berfungsi jika Anda tidak memiliki celah dalam nilai enum Anda, tetapi itu sering terjadi.

Tetapi bagaimana jika beberapa hack datang dan melempar int yang tidak diinisialisasi ke dalam fungsi saya yang cantik?

Kemudian Anda mendapatkan Perilaku Tidak Terdefinisi , dan Anda defaultakan menjadi tidak berarti. Tidak ada yang bisa Anda lakukan untuk menjadikan ini lebih baik.

Biarkan saya lebih jelas. Instan seseorang meneruskan inisialisasi intke fungsi Anda, itu adalah Perilaku Tidak Terdefinisi. Fungsi Anda dapat memecahkan Masalah Pemutusan dan tidak masalah. Itu adalah UB. Tidak ada yang dapat Anda lakukan setelah UB dipanggil.

Pernyataan default tidak selalu membantu. Jika sakelar lebih dari enum, nilai apa pun yang tidak didefinisikan dalam enum akan berakhir menjalankan perilaku yang tidak ditentukan.

Untuk semua yang Anda tahu, kompiler dapat mengkompilasi saklar itu (dengan default) sebagai:

if (theMask == MaskValueUno)
  // Execute something MaskValueUno code
else // theMask == MaskValueDos
  // Execute MaskValueDos code

Setelah Anda memicu perilaku yang tidak terdefinisi, tidak ada jalan untuk kembali.

Saya juga lebih suka memiliki default:dalam semua kasus. Saya terlambat ke pesta seperti biasa, tapi ... beberapa pemikiran lain yang tidak saya lihat di atas:

• Peringatan khusus (atau kesalahan jika juga melempar -Werror) berasal dari -Wcovered-switch-default(dari -Weverythingtetapi tidak -Wall). Jika fleksibilitas moral Anda memungkinkan Anda mematikan peringatan tertentu (mis. Cukai beberapa hal dari -Wallatau -Weverything), pertimbangkan untuk melempar -Wno-covered-switch-default(atau -Wno-error=covered-switch-defaultketika menggunakan -Werror), dan secara umum -Wno-...untuk peringatan lain yang menurut Anda tidak menyenangkan.
• Untuk gcc(dan perilaku yang lebih generik di clang), konsultasikan gccmanualnya untuk -Wswitch, -Wswitch-enum, -Wswitch-defaultuntuk (yang berbeda) perilaku dalam situasi yang sama dari jenis yang disebutkan dalam laporan beralih.

• Saya juga tidak suka peringatan ini dalam konsep, dan saya tidak suka kata-katanya; bagi saya, kata-kata dari peringatan ("label default ... mencakup semua ... nilai") menunjukkan bahwa default:case akan selalu dieksekusi, seperti

  switch (foo) {
    case 1:
      do_something(); 
      //note the lack of break (etc.) here!
    default:
      do_default();
  }

  Pada pembacaan pertama, ini adalah apa yang saya pikir Anda berjalan ke - bahwa Anda default:kasus akan selalu dieksekusi karena tidak ada break;atau return;atau serupa. Konsep ini mirip (dengan telingaku) ​​dengan komentar gaya pengasuh lainnya (meskipun kadang-kadang bermanfaat) yang muncul dari clang. Jika foo == 1, kedua fungsi akan dieksekusi; kode Anda di atas memiliki perilaku ini. Yaitu, gagal break-out hanya jika Anda ingin tetap menjaga mengeksekusi kode dari kasus-kasus berikutnya! Namun, ini tampaknya bukan masalah Anda.

Dengan risiko menjadi sombong, beberapa pemikiran lain untuk kelengkapan:

• Namun saya pikir perilaku ini (lebih) konsisten dengan memeriksa tipe agresif dalam bahasa lain atau kompiler. Jika, ketika Anda berhipotesis, beberapa reprobate memang mencoba untuk mengirimkan intatau sesuatu ke fungsi ini, yang secara eksplisit berniat untuk mengkonsumsi tipe spesifik Anda sendiri, kompiler Anda harus melindungi Anda sama baiknya dalam situasi itu dengan peringatan atau kesalahan yang agresif. TAPI tidak! (Yaitu, tampaknya paling tidak gccdan clangtidak melakukan enumpengecekan tipe, tapi saya dengar icctidak .) Karena Anda tidak mendapatkan tipe -Safety, Anda bisa mendapatkan nilai -Safety seperti dibahas di atas. Kalau tidak, seperti yang disarankan dalam TFA, pertimbangkan suatu structatau sesuatu yang dapat memberikan keamanan jenis.
• Solusi lain dapat menciptakan "nilai" baru di Anda enumseperti MaskValueIllegal, dan tidak mendukung itu casedi Anda switch. Itu akan dimakan oleh default:(selain nilai aneh lainnya)

Pengodean bertahan lama!

Berikut adalah saran alternatif:
OP berusaha melindungi terhadap kasus di mana seseorang lewat di intmana enum diharapkan. Atau, lebih mungkin, di mana seseorang telah menautkan pustaka lama dengan program yang lebih baru menggunakan header yang lebih baru dengan lebih banyak case.

Mengapa tidak mengganti sakelar untuk menangani intkasing? Menambahkan gips di depan nilai dalam switch menghilangkan peringatan dan bahkan memberikan sedikit petunjuk tentang mengapa default ada.

void myFunction(testingMask theMask) {
    int maskValue = int(theMask);
    switch(maskValue) {
        case MaskValueUno: {} // deal with it
        case MaskValueDos: {}// deal with it
        default: {} //deal with an unexpected or uninitialized value
    }
}

Saya menemukan ini jauh lebih tidak menyenangkan daripada assert()menguji masing-masing nilai yang mungkin atau bahkan membuat asumsi bahwa kisaran nilai enum disusun dengan baik sehingga tes yang lebih sederhana bekerja. Ini hanyalah cara jelek untuk melakukan apa yang default lakukan dengan tepat dan indah.