2009-07-23 75 views
15

当我在case的代码块周围使用大括号来定位变量时,我应该把break放在块的内部还是外部?在哪里把break在开关/ case语句中与块

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

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

谢谢。

+0

请问您能澄清一下吗;问题是没有道理的...... – 2009-07-23 11:12:50

+4

我认为它很有意义 – 2009-07-23 11:16:58

+0

尽管有意义,但代码示例将无一例外地使其更加清晰 – dmckee 2009-07-23 15:09:20

回答

19

这是一个风格问题。

我会把break放在右大括号之外,这样才能使它更具可读性。

2

它确实取决于你的代码的逻辑以及它如何使用大括号,但为了正确的答案,如果你把它放在里面,试着把它们全部放在里面。

14

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

+0

一致性规则!+1 – xtofl 2009-07-23 11:42:32

+0

一致性+1 :-) – 2009-07-23 14:53:41

+0

+1 I + 1刚刚毁了你的@xtofl一致性。 @MartinYork;) – 2011-03-06 20:13:35

4

我通常把break的括号内,像这样:

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

然而,因为这是我的规则我可以​​自由地打破它(没有双关语意),每当我想要的。

1

在我看来,你应该避免switch语句中的局部变量和块。无论如何,你也应该避免长时间或复杂甚至级联的开关语句。 但没有规则没有例外......我更喜欢在块之后写入break语句。

4

它应该出现后。

例如:

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

编辑的文本下面

这主要以提高可读性和可维护性这里是一个例子。

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

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

当你开始遇到嵌套switch语句的情况下,它可以变得非常混乱确实现在有

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

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) 
     break; 
     } 
     case 1: 
     { 
     //and the other...   
     } 
     break; 
    } 

花了很长的时间来拖住这个代码,但在检查更改日志它最初是作为followws:

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

不可否认,原始代码与其本身并不一致,但通过在大括号中打破代码的一行代码被意外删除时编译的代码。如果休息时间在括号外,那么它不会有。

1

只要您和您的团队始终如一地执行相同的操作,这并不重要。即便如此,如果不同的团队成员以不同的方式做这件事,这不是一个大问题。

我个人比较喜欢之后。理由是它在switch语句的机制(跳到,执行和退出)和纯粹涉及“做”情况的大括号内的代码之间给出了一些分离。

如:

switch(value) 
{ 
    case 0: 
     { 
      // code here 
     } 
     break; 

    default: 
     { 
      assert(!"unhandled value in switch"); 
     } 
     break; 
} 

我只用{}的情况下,如果需要局部变量,但如果我使用{}任何情况下,我把他们的所有情况。

我通常总是定义一个默认情况来断言是否有任何意外的值。这些断言中有一个会多次提醒你缺少一个案例,这是惊人的。

0

这是一个风格问题,但我以后把它作为我理解定义为:

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

where语句是一个单一的命令或块。休息是独立于这个声明或块。是的,我确实在缺省之后添加了一个中断,尽管它是多余的。我也总是把括号括起来的声明。我多次添加了一个语句来打破范围。因为我已将默认值更改为缺省表达式:并在其后添加了一些内容,所以我将缺省添加到缺省值。防御性编码是你的朋友。

但是,我只能找到通过Microsoft的实际定义文件为:

selection-statement: 
    switch (expression) statement 

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

这将表明它应该是内部的。

但是,从读者的角度来看,我认为外部是更清晰的,但它肯定是主观的。

0

由于标准不限制你选择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; 
    } 
4

每个人都同意我们需要的switch/case...机械在各种情况下执行的实际行动之间有清晰可辨的区别。

为此,除非真的几乎没什么每种情况下回事(简单赋值左右),我建议使用switch作为一个单纯的调度,并委托“真实”的东西辅助功能。这自动解决了case-local变量的问题,并且完全不需要大括号。

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

有很多关于仅用一个语句每箱,从来没有使用大括号的风格可说的。例如:

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

使用这种风格,你的问题是没有意义的。

1

我不喜欢在switch语句中放置任何类型的括号。就个人而言,如果它是一个复杂的操作,我喜欢把它放在一个函数中。除了在每个“案例”之间有数百行代码的切换语句之外,没有什么更让人恼火的了,而且在其中一些代码在各种情况下重复使得维护变得不可能。

例如:

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

case 2: 
    doManyThings(); 
    break; 

default: 
    // something 
    break; 
} 
0

真正的答案:编译不在乎。这是一个偏好问题。

我把它们放在里面,就像google style guide一样。

如果使用大括号,我喜欢左大括号与右大括号(它不同于谷歌)位于同一列。

switch (var) { 
    case 0: 
    { 
    ...  
    break; 
    } 
    case 1: 
    { 
    ... 
    break; 
    } 
    default: 
    assert(false); 
} 
0

我的...请看下面的例子。

缩进开关的所有情况,并在关键字switch下使用开关的右括号,就像在if语句中所做的那样。无论何时需要,每条case声明的规则相同:在case声明之后的半列之后的括号后面打开,并在关键字case下关闭它们,然后缩进包含关键字break的每个case声明的内容。

保持一致(缩进和括号的展示位置)和短期(不超过5-10的每case语句代码行。复杂的项目,因为严重缩进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; 
    }