Toutes les autres réponses défendent la règle 3 de votre professeur.
Permettez-moi de dire que je suis d'accord avec vous: la règle est redondante et je ne le conseillerais pas. Il est vrai que cela empêche théoriquement les erreurs si vous ajoutez toujours des accolades. D'un autre côté, je n'ai jamais rencontré ce problème dans la vraie vie : contrairement à ce que d'autres réponses impliquent, je n'ai pas oublié une fois d'ajouter les accolades une fois qu'elles sont devenues nécessaires. Si vous utilisez une indentation appropriée, il devient immédiatement évident que vous devez ajouter des accolades une fois plus d'une instruction mise en retrait.
La réponse du «Composant 10» met en évidence le seul cas envisageable où cela pourrait vraiment conduire à une erreur. Mais d'un autre côté, le remplacement de code via une expression régulière mérite toujours un énorme soin.
Regardons maintenant l'autre côté de la médaille: y a-t-il un inconvénient à toujours utiliser des accolades? Les autres réponses ignorent simplement ce point. Mais il y a un inconvénient: cela prend beaucoup d'espace vertical à l'écran, ce qui peut rendre votre code illisible car cela signifie que vous devez faire défiler plus que nécessaire.
Considérez une fonction avec beaucoup de clauses de garde au début (et oui, ce qui suit est un mauvais code C ++ mais dans d'autres langages, ce serait une situation assez courante):
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);
}
C'est un code horrible, et je soutiens fermement que ce qui suit est beaucoup plus lisible:
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);
}
De même, les boucles imbriquées courtes bénéficient de l'omission des accolades:
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;
}
Comparer avec:
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;
}
Le premier code est concis; le deuxième code est gonflé.
Et oui, cela peut être atténué dans une certaine mesure en mettant l'accolade d'ouverture sur la ligne précédente. Mais cela serait toujours moins lisible que le code sans accolades.
En bref: n'écrivez pas de code inutile qui occupe de l'espace à l'écran.