Bir case deyiminde {} kullanmak. Neden?

Bir ifadede {ve kullanmanın amacı nedir ? Normalde, bir ifadede kaç satır olursa olsun , tüm satırlar çalıştırılır. Bu sadece eski / yeni derleyiciler için bir kural mı yoksa bunun arkasında bir şey mi var?}casecase

int a = 0;
switch (a) {
  case 0:{
    std::cout << "line1\n";
    std::cout << "line2\n";
    break;
  }
}

ve

int a = 0;
switch (a) {
  case 0:
    std::cout << "line1\n";
    std::cout << "line2\n";
    break;
}

{}Yeni bir bloğu belirtmektedir kapsamı .

Aşağıdaki çok uydurma örneği düşünün:

switch (a)
{
    case 42:
        int x = GetSomeValue();
        return a * x;
    case 1337:
        int x = GetSomeOtherValue(); //ERROR
        return a * x;
}

xKapsamda zaten tanımlandığı için bir derleyici hatası alırsınız .

Bunları kendi alt kapsamlarına ayırmak x, switch ifadesinin dışında bildirim yapma ihtiyacını ortadan kaldıracaktır .

switch (a)
{
    case 42: {
        int x = GetSomeValue();
        return a * x; 
    }
    case 1337: {
        int x = GetSomeOtherValue(); //OK
        return a * x; 
    }
}

TL; DR

Bir vaka içinde başlatıcı veya önemsiz olmayan bir nesneye sahip bir değişken tanımlamanın tek yolu, bir döngü veya if ifadesi gibi kendi kapsamına sahip bir blok kapsamını{} veya başka bir kontrol yapısını kullanmaktır. .

Kanlı ayrıntılar

Durumların , bir goto ifadesiyle kullanılan etiketler gibi yalnızca etiketli ifadeler olduğunu görebiliriz ( bu, C ++ taslak standart bölüm 6.1 Etiketli ifadede ele alınmıştır ) ve 3. paragrafta , birçok durumda beyannameyi geçmeye izin verilmediğini görebiliriz. , başlatmaya sahip olanlar dahil:6.7

Bir bloğa transfer etmek mümkündür, ancak başlatma ile bildirimleri atlayacak şekilde değil. Atlayan bir program ⁸⁷ otomatik depolama süresine sahip bir değişken o kapsamda bir noktaya kapsamında olmayan bir noktadan, değişken önemsiz bir varsayılan yapıcı ve önemsiz bir yıkıcının ile skaler tip, sınıf türüne sahip olmadıkça kötü şekillendirilmiş olan bu türlerden birinin cv nitelikli bir sürümü veya önceki türlerden birinin bir dizisi ve bir başlatıcı olmadan bildirilir (8.5).

ve şu örneği sağlar:

void f() {
 // ...
 goto lx; // ill-formed: jump into scope of a

 ly:
  X a = 1;
 // ...
 lx:
  goto ly; // OK, jump implies destructor
          // call for a followed by construction
          // again immediately following label ly
}

Unutmayın, burada bazı incelikler vardır, başlatma içermeyen skaler bir bildirimi atlamanıza izin verilir , örneğin:

switch( n ) 
{
    int x ;
    //int x  = 10 ; 
    case 0:
      x = 0 ;
      break;
    case 1:
      x = 1 ;
      break;
    default:
      x = 100 ;
      break ;
}

tamamen geçerlidir ( canlı örnek ). Elbette, her durumda aynı değişkeni beyan etmek istiyorsanız, o zaman her birinin kendi kapsamına ihtiyacı olacaktır, ancak switch ifadelerinin dışında da aynı şekilde çalışır , bu yüzden bu büyük bir sürpriz olmamalıdır.

Başlangıca atlamaya izin vermeme gerekçesine gelince, kusur raporu 467 , biraz farklı bir konuyu kapsasa da otomatik değişkenler için makul bir durum sağlar :

[...] otomatik değişkenler, açık bir şekilde başlatılmamışsa, tuzak gösterimleri de dahil olmak üzere belirsiz ("çöp") değerlere sahip olabilir, [...]

Bir içinde kapsamını genişletmek nerede durumda bakmak için muhtemelen daha ilginç anahtarı çoklu üzerinde vakaların bu en ünlü örnekleri muhtemelen Duff aygıtı şöyle görünecektir:

void send( int *to, const int *from, int  count)
{
        int n = (count + 7) / 8;
        switch(count % 8) 
        {
            case 0: do {    *to = *from++;   // <- Scope start
            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);    // <- Scope end
        }
}

Değişken bildirimlerini sonuçta ortaya çıkan yıkıcı (veya kapsam çatışmaları) ile birlikte casecümlelere enjekte etmenize izin veren bir alışkanlıktır . Buna bakmanın bir başka yolu da, tüm akış kontrolünün ifade dizilerinden değil bloklardan oluştuğu, diledikleri dil için yazıyor olmalarıdır.

Bunu temel bir derleyici kısıtlaması olarak kontrol edin ve neler olduğunu merak etmeye başlayacaksınız:

int c;
c=1;

switch(c)
{
    case 1:
    //{
        int *i = new int;
        *i =1;
        cout<<*i;
        break;
    //}

    default : cout<<"def";
}

Bu size bir hata verecektir:

error: jump to case label [-fpermissive]
error:   crosses initialization of ‘int* i’

Bu olmayacak olsa da:

int c;
c=1;

switch(c)
{
    case 1:
    {
        int *i = new int;
        *i =1;
        cout<<*i;
        break;
    }

    default : cout<<"def";
}

Anahtarda parantez kullanmak, Rotem'in söylediği gibi yeni bir kapsam bloğunu belirtir.

Ancak okuduğunuzda netlik açısından da olabilir. Koşullu bir kırılma yaşayabileceğiniz için davanın nerede durduğunu bilmek.

Sebepler şunlar olabilir:

1. Okunabilirlik, kapsamlı bir bölüm olarak her durumu görsel olarak geliştirir.
2. Birkaç anahtar durumu için aynı ada sahip farklı bir değişken bildirmek.
3. Mikro optimizasyonlar - vakanın kapsamından çıkar çıkmaz yok etmek istediğiniz, gerçekten pahalı bir kaynak tahsisli değişkenin kapsamı veya hatta "GOTO" komut kullanımının daha spagetti senaryosu.