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.