Anahtar ifadeleri her zaman varsayılan bir cümle içermeli mi?

İlk kod incelemelerimden birinde (bir süre önce), tüm anahtar ifadelerinde varsayılan bir cümle eklemenin iyi bir uygulama olduğu söylendi. Son zamanlarda bu tavsiyeyi hatırladım ama gerekçesinin ne olduğunu hatırlayamıyorum. Şimdi bana oldukça garip geliyor.

1. Her zaman varsayılan bir ifade eklemenin mantıklı bir nedeni var mı?

2. Bu dil bağımlı mı? O sırada hangi dili kullandığımı hatırlamıyorum - belki bu bazı diller için geçerlidir, diğerleri için geçerli değildir?

Anahtar kutuları neredeyse her zaman bir defaultdavaya sahip olmalıdır .

Kullanmak için nedenler default

Beklenmeyen bir değeri 'yakalamak'

switch(type)
{
    case 1:
        //something
    case 2:
        //something else
    default:
        // unknown type! based on the language,
        // there should probably be some error-handling
        // here, maybe an exception
}

2. Vakaların özel davranış için olduğu 'varsayılan' eylemleri işlemek.

Bu, menü odaklı programlarda ve bash kabuk komut dosyalarında LOT görürsünüz. Ayrıca, bir değişken anahtar durumunun dışında bildirildiğinde ancak başlatılmadığında ve her durum bunu farklı bir şeye başlattığında da görebilirsiniz. Burada, varsayılan değerin de başlatılması gerekir, böylece değişkene erişen satır kodunun aşağısında bir hata oluşmaz.

3. Kodunuzu okuyan birine bu konuyu kapsadığınızı göstermek için.

variable = (variable == "value") ? 1 : 2;
switch(variable)
{
    case 1:
        // something
    case 2:
        // something else
    default:
        // will NOT execute because of the line preceding the switch.
}

Bu çok basitleştirilmiş bir örnektir, ancak asıl nokta, kodu okuyan birinin neden merak etmemesi gerektiğidir variable 1 veya 2'den başka bir şey etmemesi gerektiğidir.

Ben DEĞİL kullanımına düşünebildiğim tek vaka defaultolduğu anahtar onun yerine bariz her alternatif mutlulukla göz ardı edilebilir bir şey kontrol edildiğinde

switch(keystroke)
{
    case 'w':
        // move up
    case 'a':
        // move left
    case 's':
        // move down
    case 'd':
        // move right
    // no default really required here
}

Hayır.

Varsayılan bir eylem yoksa içerik önemlidir. Ya sadece birkaç değer üzerinde hareket etmeyi önemsiyorsanız?

Bir oyun için tuşlara basma örneğini ele alalım

switch(a)
{
   case 'w':
     // Move Up
     break;
   case 's':
     // Move Down
     break;
   case 'a':
     // Move Left
     break;
   case 'd':
     // Move Right
     break;
}

Ekleme:

default: // Do nothing

Sadece zaman kaybıdır ve hiçbir nedenle kodun karmaşıklığını artırır.

Varsayılan durumda OLMAMASI bazı durumlarda gerçekten yararlı olabilir.

Anahtar durumlarınız numaralandırma değerleriyse, varsayılan bir durum yoksa, herhangi bir vakayı kaçırmazsanız derleyici uyarısı alabilirsiniz. Bu şekilde, gelecekte yeni numaralandırma değerleri eklenirse ve anahtarda bu değerler için vakalar eklemeyi unutursanız, derleme sırasında sorun hakkında bilgi edinebilirsiniz. Numara türüne geçersiz bir değer verildiğinde, kodun işlenmemiş değerler için uygun eylemi gerçekleştirdiğinden emin olmalısınız. Bu nedenle, enum, mola yerine numaralandırma durumuna geri dönebileceğiniz basit durumlar için işe yarayabilir.

enum SomeEnum
{
    ENUM_1,
    ENUM_2,
    // More ENUM values may be added in future
};

int foo(SomeEnum value)
{
    switch (value)
    {
    case ENUM_1:
        return 1;
    case ENUM_2:
        return 2;
    }
    // handle invalid values here
    return 0;
 }

Hangi dilde çalışıyor olursanız olun, her zaman varsayılan bir cümle kullanırdım.

İşler yanlış gidebilir. Değerler beklediğiniz gibi olmayacak vb.

Varsayılan bir cümle eklemek istememeniz, olası değerler kümesini bildiğinizden emin olduğunuz anlamına gelir. Olası değerler kümesini bildiğinize inanıyorsanız, değer bu olası değerler kümesinin dışındaysa, bundan haberdar olmak istersiniz - bu kesinlikle bir hatadır.

Java'da her zaman varsayılan bir cümle kullanmanız ve bir hata atmanızın nedeni budur:

switch (myVar) {
   case 1: ......; break;
   case 2: ......; break;
   default: throw new RuntimeException("unreachable");
}

"Ulaşılamayan" dizeden daha fazla bilgi eklemek için hiçbir neden yoktur; gerçekte olursa, değişkenlerin kaynağına ve değerlerine zaten bakmanız gerekecek ve istisna stacktrace bu satır numarasını içerecektir, bu nedenle istisna mesajına daha fazla metin yazarak zaman kaybetmenize gerek yoktur.

Şirketimde, Aviyonik ve Savunma pazarı için yazılım yazıyoruz ve her zaman varsayılan bir ifade ekliyoruz, çünkü bir anahtar ifadesindeki TÜM vakalar açıkça ele alınmalıdır ('Hiçbir şey yapma' diyen bir yorum olsa bile). Yazılımı yalnızca beklenmedik (hatta imkansız olduğunu düşündüğümüz) değerlerin yanlış davranması veya çökmesi için karşılayamayız.

Varsayılan bir vakanın her zaman gerekli olmadığı tartışılabilir, ancak her zaman gerekmesi halinde, kod analizcilerimiz tarafından kolayca kontrol edilir.

Bir "switch" deyimi her zaman varsayılan bir cümle içermeli mi? Hayır . Genellikle bir varsayılan içermelidir .

Varsayılan bir cümle eklemek, yalnızca bir hata koşulu ileri sürmek veya varsayılan bir davranış sağlamak gibi bir şey varsa mantıklıdır. Bir "adil çünkü" dahil kargo kült programlama ve hiçbir değer sağlamaz. Tüm "if" ifadelerinin "else" içermesi gerektiğini söylemenin "geçiş" karşılığıdır.

Aşağıda, hiçbir anlam ifade etmediği önemsiz bir örnek verilmiştir:

void PrintSign(int i)
{
    switch (Math.Sign(i))
    {
    case 1:
        Console.Write("positive ");
        break;
    case -1:
        Console.Write("negative ");
        break;
    default: // useless
    }
    Console.Write("integer");
}

Bu şuna eşdeğerdir:

void PrintSign(int i)
{
    int sgn = Math.Sign(i);
    if (sgn == 1)
        Console.Write("positive ");
    else if (sgn == -1)
        Console.Write("negative ");
    else // also useless
    {
    }
    Console.Write("integer");
}

Gördüğüm kadarıyla cevap 'varsayılan' isteğe bağlıdır, bir anahtarın her zaman bir varsayılan içermesi gerektiğini söylemek her 'if-elseif' bir 'else' içermesi gerektiğini söylemek gibidir. Varsayılan olarak yapılacak bir mantık varsa, 'default' ifadesi orada olmalıdır, ancak aksi takdirde kod hiçbir şey yapmadan yürütülmeye devam edebilir.

Gerçekten gerekmediğinde varsayılan bir cümleye sahip olmak Defansif programlama Bu, çok fazla hata işleme kodu nedeniyle genellikle aşırı karmaşık olan koda yol açar. Bu hata işleme ve algılama kodu, kodun okunabilirliğine zarar verir, bakımı zorlaştırır ve sonunda çözdüğünden daha fazla hataya yol açar.

Bu yüzden varsayılana ulaşılmaması gerekiyorsa - eklemeniz gerekmediğine inanıyorum.

"Ulaşılmaması gereken" ifadesinin, yazılımda bir hata olması durumunda kullanıcı girişi vb. Nedeniyle istenmeyen değerler içerebilecek değerleri test etmeniz gerektiğini belirtir.

Dile bağlı olduğunu söyleyebilirim, ancak bir enum türünü açıyorsanız ve olası her değeri işlerseniz, muhtemelen varsayılan bir durum dahil DEĞİLDİR. Bu şekilde, daha sonra ek bir numaralandırma etiketi ekler ve anahtara eklemeyi unutursanız, yetkili bir derleyici size eksik vaka hakkında bir uyarı verecektir.

Switch deyiminin yalnızca kesin olarak tanımlanmış bir etiket veya değer kümesi olacağını biliyorsanız, bunu yalnızca temelleri kapsayacak şekilde yapın, böylece her zaman geçerli sonuç elde edersiniz. diğer değerler için en iyi işleyici olun.

switch(ResponseValue)
{
    default:
    case No:
        return false;
    case Yes;
        return true;
}

En azından Java için zorunlu değildir. JLS'ye göre, en az bir varsayılan vakanın mevcut olabileceğini söylüyor. Bu, varsayılan bir durumun kabul edilemeyeceği anlamına gelir. Bu bazen anahtar deyimini kullandığınız bağlama da bağlıdır. Örneğin Java'da, aşağıdaki anahtar bloğu varsayılan durum gerektirmez

private static void switch1(String name) {
    switch (name) {
    case "Monday":
        System.out.println("Monday");
        break;
    case "Tuesday":
        System.out.println("Tuesday");
        break;
    }
}

Ancak bir String döndürmeyi bekleyen aşağıdaki yöntemde, varsayılan durum derleme hatalarından kaçınmak için kullanışlı olur

    private static String switch2(String name) {
    switch (name) {
    case "Monday":
        System.out.println("Monday");
        return name;

    case "Tuesday":
        System.out.println("Tuesday");
        return name;

    default:
        return name;
    }
}

ancak, yalnızca sonunda bir döndürme ifadesi kullanarak varsayılan duruma sahip olmadan yukarıdaki yöntem için derleme hatasını önleyebilirsiniz, ancak varsayılan durum sağlamak bunu daha okunabilir hale getirir.

MISRA C gibi bazı (eski) kılavuzlar böyle söylüyor :

Son bir varsayılan cümle için gereklilik savunma amaçlı programlamadır. Bu madde ya uygun önlem almalı ya da neden hiçbir işlem yapılmadığına dair uygun bir yorum içermelidir.

Bu öneri güncel değildir, çünkü şu anda ilgili ölçütlere dayanmamaktadır. Göze çarpan ihmal Harlan Kassler'in söylediği şey:

Varsayılan büyük durumu bırakmak, derleyicinin işlenmemiş bir durum gördüğünde isteğe bağlı olarak uyarmasını veya başarısız olmasını sağlar. Her şeyden önce statik doğrulanabilirlik herhangi bir dinamik kontrolden daha iyidir ve bu nedenle dinamik kontrole ihtiyacınız olduğunda değerli bir fedakarlık yapmaz.

Harlan'ın da gösterdiği gibi, varsayılan bir vakanın işlevsel eşdeğeri anahtardan sonra yeniden oluşturulabilir. Bu, her vaka erken bir dönüş olduğunda önemsizdir.

Dinamik bir kontrol için tipik ihtiyaç, geniş anlamda giriş işlemedir. Programın kontrolünün dışından bir değer gelirse buna güvenilemez.

Bu aynı zamanda Misra'nın aşırı savunma programcılığı bakış açısını aldığı yerdir , böylece geçersiz bir değer fiziksel olarak temsil edilebilir olduğu sürece, programın doğru olup olmadığı fark edilmeden kontrol edilmelidir. Bu, yazılımın donanım hatalarının varlığında mümkün olduğunca güvenilir olması gerektiğinde mantıklıdır. Ancak Ophir Yoktan'ın dediği gibi, çoğu yazılım hataları "ele almamak" için daha iyidir. İkinci uygulamaya bazen saldırgan programlama denir .

Gelmesi beklenen değerleri yakalamak için bir varsayılan olması gerekir.

Ancak, Adrian Smith ile varsayılan hata mesajınızın tamamen anlamsız bir şey olması gerektiğini kabul etmiyorum. Kullanıcınızı göreceğiniz ("ulaşılamayan" gibi bir mesaj tamamen anlamsızdır ve bu durumda kimseye yardım etmez.

Durumda, kaç kez tamamen anlamsız bir BSOD yaşadınız? Yoksa ölümcül bir istisna @ 0x352FBB3C32342?

Anahtar değeri ( anahtar (değişken )) varsayılan duruma ulaşamazsa, varsayılan duruma hiç gerek yoktur. Varsayılan durumu koretsek bile, hiç yürütülmez. Ölü kod.

Opsiyonel bir kodlama 'sözleşmesidir'. Kullanıma bağlı olarak gerekli olup olmadığıdır. Şahsen ben buna ihtiyacınız yoksa orada olmaması gerektiğine inanıyorum. Neden kullanıcı tarafından kullanılmayacak veya ulaşmayacak bir şey eklemelisiniz?

Vaka olasılıkları sınırlıysa (yani bir Boolean), varsayılan fıkra gereksizdir !

Bir switchdeyimde varsayılan bir durum yoksa, bu durum bir aşamada ortaya çıkarsa, bu durum geliştirme aşamasında öngörülemeyen bir davranış olabilir. Bir defaultdava eklemek iyi bir uygulamadır .

switch ( x ){
  case 0 : { - - - -}
  case 1 : { - - - -}
}

/* What happens if case 2 arises and there is a pointer
* initialization to be made in the cases . In such a case ,
* we can end up with a NULL dereference */

Böyle bir uygulama, NULL dereference , bellek sızıntısı ve diğer ciddi hata türlerine neden olabilir. .

Örneğin, her koşulun bir işaretçi başlattığını varsayarız. Ancak, defaultvakanın ortaya çıkması gerekiyorsa ve bu durumda başlatmazsak, boş bir işaretçi istisnasıyla her iniş olasılığı vardır. Bu nedenle default, önemsiz olsa da, bir vaka bildirimi kullanılması önerilir .

Enum tarafından kullanılan anahtarda varsayılan durum gerekli olmayabilir. anahtar tüm değeri içerdiğinde, varsayılan durum hiçbir zaman yürütülmez. Bu durumda, gerekli değildir.

Belirli bir dilde anahtarın nasıl çalıştığına bağlıdır, ancak hiçbir dilde hiçbir eşleşme olmadığında, yürütme uyarı vermeden switch deyiminden geçer. Bazı değerler kümesi beklediğinizi ve bunları anahtarda işlediğinizi, ancak girdide başka bir değer elde ettiğinizi düşünün. Hiçbir şey olmuyor ve hiçbir şey olmadığını bilmiyorsunuz. Davayı varsayılan olarak yakaladıysanız, yanlış bir şey olduğunu bilirsiniz.

Yukarıdaki Vanwaril'in en çok oylanan yanıtıyla aynı fikirde değilim.

Herhangi bir kod karmaşıklık ekler. Ayrıca bunun için testler ve dokümantasyon yapılmalıdır. Bu yüzden daha az kod kullanarak programlamak her zaman iyidir. Benim düşüncem, kapsamlı anahtar ifadeleri için varsayılan bir yan tümce kullanırken ben kapsamlı olmayan anahtar ifadeleri için varsayılan bir yan tümcesi kullanmak olduğunu. Bunu doğru yaptığımdan emin olmak için bir statik kod analiz aracı kullanıyorum. Şimdi ayrıntılara girelim:

1. Kapsamlı olmayan anahtar ifadeleri: Bunların her zaman varsayılan bir değeri olmalıdır. Adından da anlaşılacağı gibi, bunlar olası tüm değerleri içermeyen ifadelerdir. Bu da mümkün olmayabilir, örneğin bir tamsayı değerinde veya bir String üzerinde bir switch deyimi. Burada Vanwaril örneğini kullanmak istiyorum (Yanlış bir öneri yapmak için bu örneği kullandığını düşünüyorum. Ben burada tersini belirtmek için kullanın -> Varsayılan bir ifade kullanın):

   switch(keystroke)
   {
     case 'w':
       // move up
     case 'a':
       // move left
     case 's':
       // move down
     case 'd':
       // move right
     default:          
       // cover all other values of the non-exhaustive switch statement
   }
   

   Oynatıcı başka herhangi bir tuşa basabilir. Sonra hiçbir şey yapamadık (bu, yalnızca varsayılan duruma bir yorum ekleyerek kodda gösterilebilir) veya örneğin ekranda bir şey yazdırmalıdır. Bu durum, olabileceği için konuyla ilgilidir.

2. Kapsamlı anahtar ifadeleri: Bu anahtar ifadeleri olası tüm değerleri kapsar, örneğin, sınıf sistemi türlerinin numaralandırılmasıyla ilgili bir anahtar ifadesi. İlk kez kod geliştirirken tüm değerleri kapsamak kolaydır. Bununla birlikte, biz insan olarak bazılarını unutmak için küçük bir şans var. Ayrıca daha sonra bir enum değeri eklerseniz, tüm switch deyimlerinin tam olmasını sağlayacak şekilde uyarlanması gerekir, hata cehenneminin yolunu açar. Basit çözüm, statik bir kod analiz aracıdır. Araç, tüm anahtar ifadelerini kontrol etmeli ve bunların kapsamlı olup olmadığını veya varsayılan bir değere sahip olup olmadığını kontrol etmelidir. Burada kapsamlı bir anahtar ifadesi için bir örnek. İlk önce bir numaraya ihtiyacımız var:

   public enum GradeSystemType {System1To6, SystemAToD, System0To100}
   

   O zaman bu sıralamanın bir değişkenine ihtiyacımız var GradeSystemType type = .... Daha sonra kapsamlı bir anahtar ifadesi şöyle görünecektir:

   switch(type)
   {
     case GradeSystemType.System1To6:
       // do something
     case GradeSystemType.SystemAToD:
       // do something
     case GradeSystemType.System0To100:
       // do something
   }
   

   Bu nedenle GradeSystemType, örneğin System1To3, statik kod analiz aracını genişletirsek, varsayılan bir hüküm olmadığını ve switch deyiminin kapsamlı olmadığını tespit etmeliyiz, bu yüzden tasarruf ediyoruz.

Ek bir şey daha var. Her zaman bir defaultcümle kullanırsak , statik kod analiz aracının her zaman cümleyi tespit ettiği için ayrıntılı veya kapsamlı olmayan anahtar ifadelerini tespit defaultedemeyebilir. Numarayı başka bir değerle genişletirsek ve bir anahtar ifadesine eklemeyi unutursak, bu çok kötü bir durumdur.

Anahtar ifadeleri her zaman varsayılan bir cümle içermeli mi? Varsayılan durum dışında anahtar durumu bulunamaz, anahtar durumunda varsayılan durum switch(x)bu durumda x diğer durum değerleriyle eşleşmediğinde anahtar değerini tetikler .

Bu oldukça dile özgü ve C ++ durumda enum sınıfı için küçük bir nokta olduğuna inanıyorum türü . Hangi geleneksel C enum daha güvenli görünüyor. FAKAT

Eğer std :: byte uygulanmasına bakarsanız onun gibi bir şey:

enum class byte : unsigned char {} ;

Kaynak: https://en.cppreference.com/w/cpp/language/enum

Ayrıca şunu da düşünün:

Aksi takdirde, T, altta yatan sabit tiple kapsamlandırılmış veya kapsamı kapatılmamış bir numaralandırma türüyse ve hazırlanmış init listesinin yalnızca bir başlatıcısı varsa ve başlatıcıdan altta yatan türe dönüşümün daralmadığı ve başlatma doğrudan liste başlatmadır, daha sonra numaralandırma, başlatıcıyı altta yatan tipe dönüştürmenin sonucu ile başlatılır.

(C ++ 17'den beri)

Kaynak: https://en.cppreference.com/w/cpp/language/list_initialization

Enumerator tanımlı olmayan değerleri temsil eden enum sınıfının bir örneğidir. Bu nedenle numaralara tam güvenemezsiniz. Uygulamaya bağlı olarak bu önemli olabilir.

Ancak, @Harlan Kassler'in görevinde söylediklerini gerçekten çok seviyorum ve bu stratejiyi bazı durumlarda kendim kullanmaya başlayacağım.

Güvensiz numaralandırma sınıfına sadece bir örnek:

enum class Numbers : unsigned
{
    One = 1u,
    Two = 2u
};

int main()
{
    Numbers zero{ 0u };
    return 0;
}