C++ 在何处放置带块的中断开关/案例语句

在C++中使用括号围绕C++ >代码>代码块来本地化变量时，我应该把代码<破/ <代码>放在块内还是在块外？

case FOO:  // 'break' inside
  {
    int i;
    doStuff();
    break;
  }

case BAR: // 'break' outside
  {
    int i;
    doStuff();
  }
  break;

---

谢谢。

这实际上取决于代码的逻辑以及它如何使用大括号，但是为了得到正确的答案，如果你把一个放进去，试着把所有的都放进去。

你可以把它放在你喜欢的任何地方。确保在整个项目中保持一致。（我个人把它放在外面。）

这是风格的问题

---

我会把

break

放在右大括号外，只是为了让它更可读。

我通常把

break

放在大括号内，如下所示：

switch (foo) {
    case bar: {
        int x = 5;
        printf("%d\n", x);
        break;
    }
    case baz: {
        // ...
        break;
    }
}

switch(variable) {
    break; case 1 : statement;
    break; case 2 : {
       code in a block;
    }
    break; case 3 : other statement;
    /****/ case 4 : fall-through here on purpose.
    break; default: default behavior;
}

---

然而，因为这是我的规则，我可以随时打破它（没有双关语的意思）。

我认为你应该避免在switch语句中使用局部变量和块。另外，无论如何，您应该避免使用长的、复杂的甚至是级联的switch语句。

---

但是没有规则没有例外。。。我更喜欢在块后面写break语句。

它应该出现在块后面

例如：

switch(value)
{
   case 0:
   {
   // this ...
   // that ...
   // and the other ...
   }
   break;
}

switch( cond ) { default: foo(); break; case 0: bar(); break; case 1: baz(); break; }

switch(blah)
{
 case 1:
  // do one thing
  break;

 case 2:
  doManyThings();
  break;

 default:  
  // something
  break;
}

下面编辑的文本

这主要是为了提高可读性和可维护性，下面是一个例子

switch (value)
{
   case 0:
    // Do this...
    // Do that...
    break;
   case 1:
    //and the other...
   break;
}

及

现在与

switch (value)
{
   case 0:
   {
    // Do this...
    // Do that...
   }
   break;
   case 1:
    //and the other...
   break;
}

及

当您开始遇到嵌套switch语句的情况时，它确实会变得非常混乱

只是一个指针。

现在你们中的一些人仍在想我的意思。给你。一段遗留代码停止工作，没有人能找出原因。这一切归结为一段代码，其结构如下：

   switch (value)
    {
       case 0:
       {
        // Do this...
        // Do that...
        if (ObjectWithinScope.Type == Fault)
        break;
       }
       case 1:
       {
        //and the other...           
       }
       break;
    }

花了很长时间才确定这段代码，但在检查更改日志时，最初是这样的：

   switch (value)
    {
       case 0:
       {
        // Do this...
        // Do that...
        if (ObjectWithinScope.Type == Fault)
            // *** A line of code was here ***
        break;
       }
       case 1:
       {
        //and the other...           
       }
       break;
    }

---

诚然，原始代码本身并不一致，但在意外删除一行代码时，代码在花括号内出现了中断，从而编译了代码。如果突破不在括号内，那么就没有了。

只要你和你的团队始终如一地做同样的事情，这其实并不重要。即使如此，如果不同的团队成员做得不同，也不是什么大问题

我个人更喜欢后。理由是它在switch语句的机制（跳转到、执行东西和跳出）和括号内的代码之间提供了一些分离，括号内的代码纯粹涉及到案例的“执行”

例如：

我只在需要局部变量的情况下使用{}，但是如果我在任何情况下使用{}，我会在所有情况下使用它们

---

如果有任何意外值，我通常会定义一个默认案例来断言。令人惊讶的是，这些断言中有一个经常触发以提醒您丢失的案例。

这是风格的问题，但我把它放在后面，因为我理解其定义为：

switch (variable)
{
    case expression:
        statement;
        break;
    default:
        statement;
        break;
}

where语句是单个命令或块。中断与此语句或块分开。是的，我确实在默认值之后添加了一个中断，尽管这是多余的。我也总是在语句周围加括号。太多次我向中添加了一条语句，只是为了打破范围。我在默认值中添加break，因为我已经将default:to case expression:更改为case expression:并在其后面添加了一些内容。防御性编码是你的朋友

但是，我只能通过Microsoft找到实际定义的文档，如下所示：

selection-statement:
    switch ( expression ) statement

labeled-statement:
    case constant-expression : statement
    default : statement

这表明它应该在里面

---

然而，我认为从读者的角度来看，外部更为清晰，但这肯定是主观的。

因为标准并没有限制您选择

break

语句的位置，所以您可以选择您喜欢的任何内容。就我个人而言，我使用以下风格：

 switch ( some_var ) {
        case 1: {
            // lot of code here
        } break;
        case 2: /* one call */ break;
        case 3: /* one call */ break;
        case 4: {
            // lot of code here again
        } break;
    }

---

每个人都同意，我们希望在

开关/外壳…

机械和每个外壳中执行的实际操作之间有一个清晰可识别的区别

因此，除非在每种情况下都几乎什么都没有发生（简单赋值之类），否则我建议使用

开关

作为一个简单的分派器，并将“真实”的内容委托给助手函数。这自动解决了case局部变量的问题，并且完全不再需要大括号

switch( operation ) {
  case cnegation: r = -value; break;
  case cinversion: r = 1./r; break;
  case cfaculty: { 
    double r = value; 
    while( value != 1 ) 
      r *= --value; 
  }
  break;
}

然后应该成为

switch( operation ) {
  case cnegation : r = negate (value) ; break;
  case cinversion: r = invert (value) ; break;
  case cfaculty  : r = faculty(value) ; break;
}

---

对于每个案例只使用一条语句，而从不使用大括号的风格，有很多值得一提的地方。例如：

switch(value)
{
   case 0:
   {
   // this ...
   // that ...
   // and the other ...
   }
   break;
}

switch( cond ) { default: foo(); break; case 0: bar(); break; case 1: baz(); break; }

switch(blah)
{
 case 1:
  // do one thing
  break;

 case 2:
  doManyThings();
  break;

 default:  
  // something
  break;
}

开关（cond）{ 默认值：foo（）；break； 案例0:bar（）；中断； 案例1:baz（）；断裂； }

---

使用这种方式，你的问题是没有意义的。

我不喜欢在switch语句中放任何类型的括号。就我个人而言，如果这是一个复杂的操作，我喜欢把它放在函数中。没有什么比看到switch语句更烦人的了，在每个“case”之间有数百行代码，而且其中一些代码在各种情况下重复，这使得维护变得不可能

例如：

switch(value)
{
   case 0:
   {
   // this ...
   // that ...
   // and the other ...
   }
   break;
}

switch( cond ) { default: foo(); break; case 0: bar(); break; case 1: baz(); break; }

switch(blah)
{
 case 1:
  // do one thing
  break;

 case 2:
  doManyThings();
  break;

 default:  
  // something
  break;
}

---

真正的答案：编译器不在乎。这是偏好的问题

我把它们放在里面，就像

如果使用大括号，我希望开始大括号与结束大括号位于同一列上（这与google不同）

---

我的照片。。。请参见下面的示例

缩进开关的所有外壳，并将开关的闭合括号置于关键字

switch

下，就像在

if

语句中一样。只要需要，每个

案例

语句都有相同的规则：在

案例

语句后面的半列后面打开括号，并在关键字

案例

下关闭它们，然后缩进每个

案例

语句的内容，包括关键字

中断

保持一致（缩进和括号位置）和简短（每个

case

语句不超过5-10行代码）。复杂项目失败是因为

switch

语句缩进严重，代码太多

    switch (number) {

        case 1:
            logFileStderr(VERBOSE, "MESSAGE: switch without brackets...\n");
            break;

        case 2: {
            logFileStderr(VERBOSE, "MESSAGE: switch with brackets...\n");
            break;
        }

        default:
            logFileStderr(VERBOSE, "WARNING: Unknown option...\n");
            break;
    }

---

这是一个老问题，但我认为有一些重要的东西可以补充