Qual é o objetivo de usar chaves (ou seja, {}) para uma única linha if ou loop?

Estou lendo algumas notas de aula do meu professor de C ++ e ele escreveu o seguinte:

1. Usar recuo // OK
2. Nunca confie na precedência do operador - Sempre use parênteses // OK
3. Sempre use um bloco {} - mesmo para uma única linha // não está bem , por que ???
4. Objeto Const no lado esquerdo da comparação // OK
5. Use não assinado para variáveis ​​que são> = 0 // truque legal
6. Defina o Ponteiro como NULL após a exclusão - Proteção contra exclusão dupla // não é ruim

A terceira técnica não está clara para mim: o que eu ganharia colocando uma linha em uma { ... }?

Por exemplo, pegue este código estranho:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
    if (i % 2 == 0)
    {
        j++;
    }
}

e substitua-o por:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
    if (i % 2 == 0)
        j++;

Qual é o benefício de usar a 1ª versão?

Vamos tentar também modificar iquando incrementamos j:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
    if (i % 2 == 0)
        j++;
        i++;

Ah não! Vindo do Python, isso parece ok, mas na verdade não é, pois é equivalente a:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
    if (i % 2 == 0)
        j++;
i++;

Claro, esse é um erro bobo, mas que até um programador experiente poderia cometer.

Outro motivo muito bom é apontado na resposta de ta.speot.is .

Um terceiro que eu consigo pensar é o aninhado if:

if (cond1)
   if (cond2) 
      doSomething();

Agora, suponha que você queira agora doSomethingElse()quando cond1não for atendido (novo recurso). Assim:

if (cond1)
   if (cond2) 
      doSomething();
else
   doSomethingElse();

o que está obviamente errado, uma vez que os elseassociados ao interior if.

Edit: Uma vez que isso está recebendo alguma atenção, vou esclarecer minha opinião. A pergunta que eu estava respondendo é:

Qual é o benefício de usar a 1ª versão?

Que eu descrevi. Existem alguns benefícios. Mas, IMO, regras "sempre" nem sempre se aplicam. Então eu não apoio totalmente

Sempre use um bloco {} - mesmo para uma única linha // não está bem, por que ???

Não estou dizendo que sempre use um {}bloco. Se é uma condição e comportamento bastante simples, não. Se você suspeitar que alguém possa entrar mais tarde e alterar seu código para adicionar funcionalidade, faça.

É muito fácil alterar acidentalmente o fluxo de controle com comentários, se você não usar {e }. Por exemplo:

if (condition)
  do_something();
else
  do_something_else();

must_always_do_this();

Se você comentar do_something_else()com um único comentário de linha, você terminará com o seguinte:

if (condition)
  do_something();
else
  //do_something_else();

must_always_do_this();

Compila, mas must_always_do_this()nem sempre é chamado.

Tivemos esse problema em nossa base de código, onde alguém havia desabilitado algumas funcionalidades muito rapidamente antes do lançamento. Felizmente, nós o pegamos na revisão de código.

Tenho minhas dúvidas quanto à competência do palestrante. Considerando seus pontos:

1. Está bem
2. Alguém realmente escreveria (ou gostaria de ler) (b*b) - ((4*a)*c)? Algumas precedências são óbvias (ou deveriam ser), e os parênteses extras apenas aumentam a confusão. (Por outro lado, você deve usar os parênteses em casos menos óbvios, mesmo que saiba que eles não são necessários.)
3. Tipo de. Existem duas convenções de espalhamento amplo para formatar condicionais e loops:

   if (cond) {
       código;
   }
   

   e:

   se (cond)
   {
       código;
   }
   

   No primeiro, eu concordo com ele. A abertura {não é tão visível, então é melhor assumir que está sempre lá. No segundo, no entanto, eu (e a maioria das pessoas com quem trabalhei) não tenho nenhum problema em omitir os aparelhos para uma única declaração. (Desde que, é claro, que a indentação seja sistemática e que você use esse estilo de forma consistente. (E muitos programadores muito bons, escrevendo código muito legível, omitem os chavetas, mesmo quando formatam a primeira maneira))
4. NÃO . Coisas como if ( NULL == ptr )são feias o suficiente para dificultar a legibilidade. Escreva as comparações intuitivamente. (O que em muitos casos resulta na constante à direita.) Seus 4 são maus conselhos; qualquer coisa que torne o código não natural o torna menos legível.
5. NÃO . Tudo, exceto intestá reservado para casos especiais. Para programadores experientes em C e C ++, o uso de unsignedoperadores de bits de sinais. O C ++ não possui um tipo cardinal real (ou qualquer outro tipo de subintervalo eficaz); unsignednão funciona para valores numéricos, devido às regras de promoção. Valores numéricos nos quais nenhuma operação aritmética faria sentido, como números de série, poderiam ser presumivelmente unsigned. Eu argumentaria contra, no entanto, porque envia a mensagem errada: operações bit a bit também não fazem sentido. A regra básica é que tipos integrais são int, a menos que haja um motivo significativo para o uso de outro tipo.
6. NÃO . Fazer isso sistematicamente é enganoso e, na verdade, não protege contra nada. No código OO estrito, delete this;é frequentemente o caso mais frequente (e você não pode definir thisa NULL), e de outra forma, a maioria deleteestão em destruidores, para que você não pode acessar o ponteiro depois de qualquer maneira. E configurá-lo para NULLnão faz nada com outros ponteiros flutuando. Definir o ponteiro sistematicamente para NULLdá uma falsa sensação de segurança e realmente não compra nada para você.

Veja o código em qualquer uma das referências típicas. Stroustrup viola todas as regras que você deu, exceto a primeira, por exemplo.

Eu sugiro que você encontre outro professor. Alguém que realmente sabe do que está falando.

Todas as outras respostas defendem a regra do seu professor 3.

Deixe-me dizer que concordo com você: a regra é redundante e eu não a aconselharia. É verdade que teoricamente evita erros se você sempre adiciona colchetes. Por outro lado, nunca encontrei esse problema na vida real : ao contrário do que outras respostas sugerem, nunca esqueci de adicionar os colchetes quando eles se tornaram necessários. Se você usar o recuo adequado, torna-se imediatamente óbvio que você precisará adicionar colchetes depois que mais de uma instrução for recuada.

A resposta do “Componente 10”, na verdade, destaca o único caso concebível em que isso realmente pode levar a um erro. Mas, por outro lado, a substituição de código por meio de expressão regular sempre exige muito cuidado.

Agora, vamos olhar para o outro lado da medalha: existe uma desvantagem em usar sempre colchetes? As outras respostas simplesmente ignoram esse ponto. Mas não é uma desvantagem: ele ocupa muito espaço na tela vertical, e este por sua vez, pode fazer o seu código ilegível, porque isso significa que você tem que mover-se mais do que o necessário.

Considere uma função com muitas cláusulas de guarda no início (e sim, o código a seguir é ruim para C ++, mas em outros idiomas isso seria uma situação bastante comum):

void some_method(obj* a, obj* b)
{
    if (a == nullptr)
    {
        throw null_ptr_error("a");
    }
    if (b == nullptr)
    {
        throw null_ptr_error("b");
    }
    if (a == b)
    {
        throw logic_error("Cannot do method on identical objects");
    }
    if (not a->precondition_met())
    {
        throw logic_error("Precondition for a not met");
    }

    a->do_something_with(b);
}

Este é um código horrível, e eu argumento fortemente que o seguinte é muito mais legível:

void some_method(obj* a, obj* b)
{
    if (a == nullptr)
        throw null_ptr_error("a");
    if (b == nullptr)
        throw null_ptr_error("b");
    if (a == b)
        throw logic_error("Cannot do method on identical objects");
    if (not a->precondition_met())
        throw logic_error("Precondition for a not met");

    a->do_something_with(b);
}

Da mesma forma, loops aninhados curtos se beneficiam da omissão dos colchetes:

matrix operator +(matrix const& a, matrix const& b) {
    matrix c(a.w(), a.h());

    for (auto i = 0; i < a.w(); ++i)
        for (auto j = 0; j < a.h(); ++j)
            c(i, j) = a(i, j) + b(i, j);

    return c;
}

Compare com:

matrix operator +(matrix const& a, matrix const& b) {
    matrix c(a.w(), a.h());

    for (auto i = 0; i < a.w(); ++i)
    {
        for (auto j = 0; j < a.h(); ++j)
        {
            c(i, j) = a(i, j) + b(i, j);
        }
    }

    return c;
}

O primeiro código é conciso; o segundo código está inchado.

E sim, isso pode ser atenuado até certo ponto , colocando a chave de abertura na linha anterior. Mas isso ainda seria menos legível que o código sem colchetes.

Resumindo: não escreva códigos desnecessários que ocupam espaço na tela.

A base de código em que estou trabalhando é repleta de código por pessoas com aversão patológica a aparelhos, e para as pessoas que aparecem mais tarde, realmente pode fazer a diferença na manutenção.

O exemplo problemático mais frequente que encontrei é o seguinte:

if ( really incredibly stupidly massively long statement that exceeds the width of the editor) do_foo;
    this_looks_like_a_then-statement_but_isn't;

Portanto, quando eu aparecer e desejar adicionar uma declaração, eu posso facilmente terminar com isso se não for cuidadoso:

if ( really incredibly stupidly massively long statement that exceeds the width of the editor) do_foo;
{
    this_looks_like_a_then-statement_but_isn't;
    i_want_this_to_be_a_then-statement_but_it's_not;
}

Tendo em conta que é preciso ~ 1 segundo para adicionar chaves e você pode salvar no mínimo alguns minutos confusos depuração, por que você nunca não ir com a opção reduziu-ambigüidade? Parece uma economia falsa para mim.

Meu 2c:

Usar recuo

Obviamente

Nunca confie na precedência do operador - Sempre use parênteses

Eu não usaria as palavras "nunca e" sempre ", mas em geral vejo essa regra sendo útil. Em alguns idiomas (Lisp, Smalltalk) isso não é problema.

Sempre use um bloco {} - mesmo para uma única linha

Eu nunca faço isso e nunca tive um único problema, mas posso ver como isso pode ser bom para os alunos, especialmente. se eles estudaram Python antes.

Objeto Const no lado esquerdo da comparação

Condições de Yoda? Não por favor. Dói a legibilidade. Basta usar o nível máximo de aviso ao compilar seu código.

Use não assinado para variáveis ​​que são> = 0

ESTÁ BEM. Engraçado o suficiente, ouvi Stroustrup discordar.

Definir ponteiro como NULL após exclusão - Proteção contra exclusão dupla

Mau conselho! Nunca tenha um ponteiro que aponte para um objeto excluído ou inexistente.

é mais intuitivo e facilmente compreensível. Isso torna clara a intenção.

E garante que o código não seja interrompido quando um novo usuário pode, sem saber, sentir falta dele {, }enquanto adiciona uma nova instrução de código.

Para adicionar às sugestões mais sensatas acima, um exemplo que encontrei ao refatorar algum código de onde isso se torna crítico foi o seguinte: Eu estava alterando uma base de código muito grande para alternar de uma API para outra. A primeira API teve uma chamada para definir o ID da empresa da seguinte maneira:

setCompIds( const std::string& compId, const std::string& compSubId );

considerando que a substituição precisava de duas chamadas:

setCompId( const std::string& compId );
setCompSubId( const std::string& compSubId );

Comecei a mudar isso usando expressões regulares que foram muito bem-sucedidas. Também passamos o código pelo astyle , o que realmente o tornou muito mais legível. Então, no meio do processo de revisão, descobri que, em algumas circunstâncias condicionais, isso estava mudando:

if ( condition )
   setCompIds( compId, compSubId );

Para isso:

if ( condition )
   setCompId( compId );
setCompSubId( compSubId );

o que claramente não é o que era necessário. Eu tive que voltar ao início, tratando a substituição completamente dentro de um bloco e alterando manualmente qualquer coisa que acabasse parecendo pateta (pelo menos não seria incorreta).

Percebo que o estilo agora tem a opção --add-bracketsque permite adicionar colchetes onde não há nenhum e eu recomendo isso se você se encontrar na mesma posição que eu.

Estou usando em {}qualquer lugar, exceto em alguns casos em que é óbvio. Linha única é um dos casos:

if(condition) return; // OK

if(condition) // 
   return;    // and this is not a one-liner 

Pode machucá-lo quando você adiciona algum método antes de retornar. O recuo indica que o retorno está sendo executado quando a condição é atendida, mas sempre retornará.

Outro exemplo em C # com o uso de declaração

using (D d = new D())  // OK
using (C c = new C(d))
{
    c.UseLimitedResource();
}

que é equivalente a

using (D d = new D())
{
    using (C c = new C(d))
    {
        c.UseLimitedResource();
    }
}

O exemplo mais pertinente em que consigo pensar:

if(someCondition)
   if(someOtherCondition)
      DoSomething();
else
   DoSomethingElse();

Com o qual ifo elsepar será emparelhado? A indentação implica que o externo ifrecebe o else, mas não é assim que o compilador o verá; o interior if receberá o elsee o exterior ifnão. Você precisaria saber isso (ou vê-lo se comportar dessa maneira no modo de depuração) para descobrir por inspeção por que esse código pode estar falhando em suas expectativas. Fica mais confuso se você conhece Python; nesse caso, você sabe que o recuo define os blocos de código; portanto, você esperaria que ele fosse avaliado de acordo com o recuo. O C #, no entanto, não dá a mínima para o espaço em branco.

Agora, dito isso, não concordo particularmente com esta regra "sempre use colchetes". Torna o código muito verticalmente barulhento, reduzindo a capacidade de lê-lo rapidamente. Se a declaração for:

if(someCondition)
   DoSomething();

... então deve ser escrito assim. A afirmação "sempre use colchetes" soa como "sempre envolva operações matemáticas entre parênteses". Que iria transformar a afirmação muito simples a * b + c / dpara ((a * b) + (c / d)), introduzindo a possibilidade de perder um close-paren (a ruína de um codificador muitos), e para quê? A ordem das operações é bem conhecida e aplicada, portanto os parênteses são redundantes. Você usaria apenas parênteses para impor uma ordem de operações diferente da que seria normalmente aplicada: a * (b+c) / dpor exemplo. Chaves de bloco são semelhantes; use-os para definir o que você deseja fazer nos casos em que difere do padrão e não seja "óbvio" (subjetivo, mas geralmente bastante senso comum).

Ao analisar as respostas, ninguém declarou explicitamente o tipo de prática que eu tenho o hábito de contar a história do seu código:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
    if (i % 2 == 0)
    {
        j++;
    }
}

Torna-se:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
    if (i % 2 == 0) j++;
}

Colocar j++na mesma linha que o if deve sinalizar para mais alguém: "Eu só quero que esse bloco seja incrementado j" . De coursethis só vale a pena se a linha é tão simplista quanto possível, porque colocar um ponto de interrupção aqui, como peri menciona, não vai ser muito útil.

Na verdade, eu acabei de percorrer parte da API do Twitter Storm que possui esse 'tipo' de código em java, eis o snippet relvant do código de execução, na página 43 desta apresentação de slides :

...
Integer Count = counts.get(word);
if (Count=null) count=0;
count++
...

O bloco de loop for tem duas coisas, então eu não incorporaria esse código. Ou seja, nunca :

int j = 0;
for (int i = 0 ; i < 100 ; ++i) if (i % 2 == 0) j++;

É horrível e nem sei se funciona (como pretendido); não faça isso . Novas linhas e chaves ajudam a distinguir trechos de código separados, mas relacionados, da mesma forma que uma vírgula ou um ponto e vírgula na prosa. O bloco acima é uma sentença muito longa, com algumas cláusulas e outras declarações que nunca quebram ou pausam para distinguir partes separadas.

Se você realmente deseja telegrafar para outra pessoa, é um trabalho de apenas uma linha, use um operador ou ?:formulário ternário :

for (int i = 0 ; i < 100 ; ++i) (i%2 ? 0 : >0) j++;

Mas isso está se aproximando do code-golf, e acho que não é uma boa prática (não está claro para mim se devo colocar o j ++ em um lado :ou não). NB: Eu nunca executei um operador ternário em C ++ antes, não sei se isso funciona, mas existe .

Em resumo:

Imagine como o seu leitor (ou seja, a pessoa que mantém o código) interpreta sua história (código). Deixe o mais claro possível para eles. Se você sabe que o aluno / programador iniciante está mantendo isso, talvez deixe o maior número {}possível, só para não ficar confuso.

Porque quando você tem duas declarações sem {}, é fácil perder um problema. Vamos assumir que o código se parece com isso.

int error = 0;
enum hash_type hash = SHA256;
struct hash_value *hash_result = hash_allocate();

if ((err = prepare_hash(hash, &hash_result))) != 0)
    goto fail;
if ((err = hash_update(&hash_result, &client_random)) != 0)
    goto fail;
if ((err = hash_update(&hash_result, &server_random)) != 0)
    goto fail;
if ((err = hash_update(&hash_result, &exchange_params)) != 0)
    goto fail;
    goto fail;
if ((err = hash_finish(hash)) != 0)
    goto fail;

error = do_important_stuff_with(hash);

fail:
hash_free(hash);
return error;

Parece bem. O problema com isso é realmente fácil de perder, especialmente quando a função que contém o código é muito maior. O problema é que goto failé executado incondicionalmente. Você pode facilmente imaginar o quão frustrante isso é (fazendo você perguntar por que o último hash_updatesempre falha, afinal tudo parece hash_updatefuncionar bem).

No entanto, isso não significa que sou a favor de adicionar em {}todos os lugares (na minha opinião, ver {}todos os lugares é irritante). Embora possa causar problemas, isso nunca aconteceu em meus próprios projetos, pois meu estilo de codificação pessoal proíbe condicionais sem {}que eles não estejam na mesma linha (sim, eu concordo que meu estilo de codificação não é convencional, mas eu gosto e eu use o estilo de código do projeto ao contribuir para outros projetos). Isso torna o código a seguir correto.

if (something) goto fail;

Mas não o seguinte.

if (something)
    goto fail;

Isso torna seu código mais legível, definindo claramente o escopo de seus loops e blocos condicionais. Também evita erros acidentais.

wrt 6: É mais seguro, pois excluir um ponteiro nulo não é necessário. Portanto, se você acidentalmente seguir esse caminho duas vezes, não fará com que a corrupção da memória libere a memória livre ou que tenha sido alocada para outra coisa.

Esse é o maior problema com objetos estáticos de escopo de arquivo e singletons que não têm vida útil muito clara e que são conhecidos por serem recriados após serem destruídos.

Na maioria dos casos, você pode evitar a necessidade disso usando auto_ptrs

Gosto da resposta aceita de Luchian; na verdade, aprendi da maneira mais difícil que ele está certo, então sempre uso aparelho, mesmo para blocos de linha única. No entanto, pessoalmente, faço uma exceção ao escrever um filtro, como você está no seu exemplo. Este:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
    if (i % 2 == 0)
    {
        j++;
    }
}

parece confuso para mim. Ele separa o loop for e a instrução if em ações separadas, quando realmente sua intenção é uma ação única: contar todos os números inteiros divisíveis por 2. Em uma linguagem mais expressiva, isso pode ser escrito como:

j = [1..100].filter(_%2 == 0).Count

Em idiomas que não têm fechamento, o filtro não pode ser expresso em uma única instrução, mas deve ser um loop for seguido por uma instrução if. No entanto, ainda é uma ação na mente do programador, e acredito que isso deve se refletir no código, assim:

int j = 0;
for (int i = 0 ; i < 100 ; ++i)
  if (i % 2 == 0)
{
    j++;
}

Uma opção para ajudar a evitar os erros descritos acima é alinhar o que você deseja que aconteça quando não usa aparelho. Torna muito mais difícil não perceber os erros quando você tenta modificar o código.

if (condition) doSomething();
else doSomethingElse();

if (condition) doSomething();
    doSomething2(); // Looks pretty obviously wrong
else // doSomethingElse(); also looks pretty obviously wrong

Se você é um compilador, não faz diferença. Ambos são iguais.

Mas para os programadores, o primeiro é mais claro, fácil de ler e menos propenso a erros.

Outro exemplo de adição de chaves. Uma vez eu estava procurando por um bug e encontrei esse código:

void SomeSimpleEventHandler()
{
    SomeStatementAtTheBeginningNumber1;
    if (conditionX) SomeRegularStatement;
    SomeStatementAtTheBeginningNumber2;
    SomeStatementAtTheBeginningNumber3;
    if (!SomeConditionIsMet()) return;
    OtherwiseSomeAdditionalStatement1;
    OtherwiseSomeAdditionalStatement2;
    OtherwiseSomeAdditionalStatement3;
}

Se você ler o método linha por linha, notará que existe uma condição no método que retorna se não for verdadeira. Mas, na verdade, parece com outros 100 manipuladores de eventos simples que definem algumas variáveis ​​com base em algumas condições. E um dia o Fast Coder entra e adiciona uma declaração de configuração de variável adicional ao final do método:

{
    ...
    OtherwiseSomeAdditionalStatement3;
    SetAnotherVariableUnconditionnaly;
}

Como resultado, o SetAnotherVariableUnconditionnaly é executado quando o SomeConditionIsMet (), mas o cara rápido não percebeu, porque todas as linhas são quase de tamanho semelhante e mesmo quando a condição de retorno é recuada verticalmente, não é tão perceptível.

Se o retorno condicional for formatado assim:

if (!SomeConditionIsMet())
{
    return;
}

é muito perceptível e o Fast Coder o encontrará rapidamente.

Considero o primeiro claro, depois o segundo. Dá a sensação de instruções de fechamento, com pouco código é bom quando o código fica complexo {...}ajuda muito, mesmo que seja endifoubegin...end

//first
int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
    if (i % 2 == 0)
    {
        j++;
    }
}


//second
int j = 0;
for (int i = 0 ; i < 100 ; ++i)
    if (i % 2 == 0)
        j++;
i++;

É melhor definir o ponteiro como NULL quando terminar.

Aqui está um exemplo do porquê:

A classe A faz o seguinte:

1. Aloca um bloco de memória
2. Algum tempo depois, ele exclui esse bloco de memória, mas não define o ponteiro para NULL

A classe B faz o seguinte

1. Aloca memória (e, nesse caso, recebe o mesmo bloco de memória que foi excluído pela classe A.)

Nesse ponto, tanto a Classe A quanto a Classe B têm ponteiros apontando para o mesmo bloco de memória. No que diz respeito à Classe A, esse bloco de memória não existe porque foi finalizado.

Considere o seguinte problema:

E se houvesse um erro lógico na Classe A que resultasse na gravação na memória que agora pertence à Classe B?

Nesse caso específico, você não receberá um erro de exceção de acesso incorreto porque o endereço de memória é legal, enquanto a classe A está corrompendo efetivamente os dados da classe B.

A classe B pode eventualmente travar se encontrar valores inesperados e, quando travar, as chances são de que você passará muito tempo caçando esse bug na classe B quando o problema estiver na classe A.

Se você tivesse definido o ponteiro de memória excluído como NULL, teria recebido um erro de exceção assim que qualquer erro lógico da Classe A tentasse gravar no ponteiro NULL.

Se você estiver preocupado com o erro lógico com exclusão dupla quando os ponteiros forem NULL pela segunda vez, adicione assert para isso.

Além disso: Se você estiver indo para votar, por favor, explique.

Ter sempre chaves é uma regra muito simples e robusta. No entanto, o código pode parecer deselegante quando há muitas chaves. Se as regras permitirem omitir chaves, deve haver regras de estilo mais detalhadas e ferramentas mais sofisticadas. Caso contrário, pode resultar facilmente em código caótico e confuso (não elegante). Portanto, procurar regras de estilo único separadas do restante dos guias e ferramentas de estilo usadas provavelmente é infrutífero. Trarei apenas alguns detalhes importantes sobre essa regra nº 3 que nem foram mencionados em outras respostas.

O primeiro detalhe interessante é que a maioria dos defensores dessa regra concorda em violá-la no caso de else. Em outras palavras, eles não exigem na revisão esse código:

// pedantic rule #3
if ( command == Eat )
{
    eat();
}
else
{
    if ( command == Sleep )
    {
        sleep();
    }
    else
    {
        if ( command == Drink )
        {
            drink();
        }
        else
        {
            complain_about_unknown_command();
        }
    }
}

Em vez disso, se o virem, podem até sugerir que seja escrito assim:

// not fully conforming to rule #3
if ( command == Eat )
{
    eat();
}
else if ( command == Sleep )
{
    sleep();
}
else if ( command == Drink )
{
    drink();
}
else
{
   complain_about_unknown_command();
}

Isso é tecnicamente uma violação dessa regra, pois não há colchetes entre elsee if. Essa dualidade da regra aparece quando tentar aplicá-la automaticamente à base de código com uma ferramenta irracional. Na verdade, por que argumentar, basta deixar uma ferramenta aplicar estilo automaticamente.

O segundo detalhe (que também costuma ser esquecido pelos defensores dessa regra) é que os erros que podem ocorrer nunca são apenas por causa de violações à regra # 3. Na verdade, esses quase sempre envolvem violações da regra 1 também (com a qual ninguém discute). Novamente do ponto de vista das ferramentas automáticas, não é difícil criar uma ferramenta que reclama imediatamente quando a regra 1 é violada e, portanto, a maioria dos erros pode ser detectada em tempo hábil.

O terceiro detalhe (que muitas vezes é esquecido pelos oponentes dessa regra) é a natureza confusa da declaração vazia que é representada por ponto e vírgula único. A maioria dos desenvolvedores com alguma experiência ficou confusa, mais cedo ou mais tarde, com o ponto e vírgula no lugar errado ou com a declaração vazia que foi escrita usando o ponto e vírgula único. Duas chaves em vez de ponto e vírgula são visualmente mais fáceis de detectar.

Eu tenho que admitir que nem sempre use {}para linha única, mas é uma boa prática.

• Digamos que você escreva um código sem colchetes parecido com este:

  for (int i = 0; i <100; ++ i) for (int j = 0; j <100; ++ j) DoSingleStuff ();

E depois de algum tempo, você deseja adicionar joutras informações ao loop, basta fazer isso por alinhamento e esquecer de adicionar colchetes.

• A distribuição de memória é mais rápida. Vamos dizer que você tem um grande escopo e cria grandes matrizes dentro (sem newelas estão na pilha). Essas matrizes são removidas da memória logo após você sair do escopo. Mas é possível que você use essa matriz em um único local, que ficará na pilha por um tempo e será algum tipo de lixo. Como uma pilha possui tamanho limitado e muito pequeno, é possível exceder o tamanho da pilha. Portanto, em alguns casos, é melhor escrever {}para evitar isso. OBSERVAÇÃO: não é para uma linha, mas para tais situações:

  if (...) {// SomeStuff ... {// não temos if, while, etc. // SomeOtherStuff} // SomeMoreStuff}

• A terceira maneira de usá-lo é semelhante à segunda. Apenas não para tornar a pilha mais limpa, mas para abrir algumas funções. Se você usa mutexfunções longas, geralmente é melhor bloquear e desbloquear imediatamente antes de acessar os dados e logo após terminar de ler / escrever isso. OBSERVAÇÃO desta maneira está sendo usado se você possuir um pouco classou structcom constructore destructorpara bloquear a memória.

• O que é mais:

  se (...) se (...) SomeStuff (); else SomeOtherStuff (); // vai para o segundo if, mas o alligment mostra que está no primeiro ...

No geral, não posso dizer, qual é a melhor maneira de sempre usar {}para uma única linha, mas não é nada ruim fazer isso.

EDIÇÃO IMPORTANTE Se você escrever colchetes de código de compilação para uma única linha, não fará nada, mas se o seu código for interpretado, ele diminui a velocidade do código muito, muito levemente. Muito levemente.

Existem várias maneiras possíveis de escrever instruções de controle; certas combinações delas podem coexistir sem prejudicar a legibilidade, mas outras combinações causarão problemas. O estilo

if (condition)
  statement;

coexistirá confortavelmente com algumas das outras maneiras de escrever declarações de controle, mas não tão bem com outras. Se instruções controladas por várias linhas forem escritas como:

if (condition)
{
  statement;
  statement;
}

será visualmente óbvio quais ifinstruções controlam uma única linha e quais controlam várias linhas. Se, no entanto, ifinstruções de várias linhas forem escritas como:

if (condition) {
  statement;
  statement;
}

então a probabilidade de alguém tentar estender uma ifconstrução de instrução única sem adicionar os aparelhos necessários pode ser muito maior.

A instrução de declaração única na próxima linha iftambém pode ser problemática se a base de código fizer uso significativo do formulário

if (condition) statement;

Minha preferência é que ter a declaração em sua própria linha geralmente melhore a legibilidade, exceto nos casos em que houver muitas ifdeclarações com blocos de controle semelhantes, por exemplo

if (x1 > xmax) x1 = xmax;
if (x1 < xmin) x1 = xmin;
if (x2 > xmax) x2 = xmax;
if (x2 < xmin) x2 = xmin;
etc.

nesse caso, geralmente precederei e seguirei esses grupos de ifinstruções com uma linha em branco para separá-los visualmente de outro código. Ter uma série de instruções que começam com ifo mesmo recuo fornecerá uma indicação visual clara de que há algo incomum.