web-dev-qa-db-fra.com

Raison de placer le type de fonction et le nom de la méthode sur différentes lignes de C

Je viens de commencer dans une entreprise et l'un des commentaires de style à mon premier code de code était que le type de retour et le nom de la méthode devraient être sur différentes lignes. Par exemple, cela

void foo() {
}

devrait être ceci

void
foo() {
}

J'ai toujours utilisé le premier style et je me demandais s'il y a une raison autre que la préférence personnelle, pourquoi les gens utilisent le deuxième style? Je ne pense pas que le premier fait mal à la lisibilité. Est-ce que l'autre avec les programmeurs C et les grands projets open source?

ccoding-style
16
gsingh2011

se demandait s'il y a une raison autre que la préférence personnelle, pourquoi les gens utilisent le deuxième style?

C'est un style qui était populaire au début de c, donc la raison pour laquelle c'est comme ça que c'est comme ça qu'ils l'ont fait depuis très longtemps, ils ont beaucoup de code qui ressemble à ça, et c'est quoi tout le monde est habitué à. Pas tant de préférence personnelle en tant que dynamique d'entreprise.

Une autre raison est que les noms de fonction commencent toujours dans la première colonne. Les types de retour varient en longueur et peuvent être un peu complexes - la mise sur sa propre ligne facilite la recherche du nom de la fonction.

Si la société dispose d'un style de consigne, ils peuvent également avoir un document de normes de codage. Demandez le. Cela peut expliquer la ou les raison (s) de ce choix et une copie vous aidera à éviter des problèmes similaires dans les examens futurs.

19
Caleb

C'est à peu près la seule règle de formatage de code que j'ai trouvé réellement un impact notable sur la lisibilité et il ne faut presque aucun effort (en supposant que votre éditeur de code ne commence pas à vous battre avec vous).

C'est une bonne conception de la langue de programmation à avoir des noms apparaissant dans une position cohérente dans les déclarations/définitions. La justification est simple: vous avez une jolie ancre visuelle (une attelle bouclée ou une empreinte suspendue) que vous pouvez utiliser pour trouver immédiatement le début du nom. Vous n'avez pas besoin d'analyser la langue lors de la numérisation via un fichier que vous trouverez le nom.

C'est la même chose que lorsque vous êtes en formatage d'un document: lorsque vous démarrez une nouvelle section, vous mettez le nom à l'avance en gras en gras - souvent sur sa propre ligne - non enterré quelque part, indifférencié, dans une longue phrase.

Le début de C avait des signatures très terreses: les types de retour étaient facultatifs et les types d'arguments ont été déclarés après la signature. Les noms ont également tendance à être très courts. Cela a atténué l'impact d'avoir un type de retour occasionnel compensant le nom.

double dot(x, y);

Est toujours assez digeste.

C++ a fait cela un peu pire. Il a déplacé les spécifications de type de type argument dans des signatures plus longtemps. Cette syntaxe a ensuite été adoptée lors de la normalisation de C.

static struct Origin *find_Origin(struct scoreboard *sb,
                  struct commit *parent,
                  struct Origin *Origin)

est moins digeste, mais pas trop mal. (Extrait de git)

Envisagez maintenant des pratiques de programmation modernes avec des noms de long, descriptifs et des types paramétrés et voir comment ce choix est devenu désastreux. Un exemple d'un en-tête de boost:

template <class A1, class A2, class A3, class A4, class A5, class A6>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
{ 
   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
   return result_type(); 
}

Si vous écrivez du code générique, des signatures comme celle-là ne sont même pas hors de l'ordinaire. Vous pouvez trouver des exemples de cas bien pis que cela sans essayer trop fort.

C, C++ et leurs dérivés, Java et C #, semblent être les exceptions à avoir des déclarations/définitions lisibles. Leurs prédécesseurs et leurs pairs populaires (Fortran, Algol, Pascal) Noms a placé des types de résultats Et, heureusement, beaucoup de leurs successeurs (Go, Scala, Thypscript et Swift pour nommer quelques-uns) ont également choisi des syntaxes plus lisibles.

7
user2313838

J'ai d'abord rencontré ce style sur la 19ème année de travail avec C & C++. Était à peu près déconcerté comment quelqu'un pourrait-il inventer ce mauvais chose.

Le seul point positif (potentiellement) positif que je pouvais trouver est que vous pouvez trouver la définition de funciton à l'aide de Grep ^ Funcname. Peut-être que la pertinence facteur décennie + dans certains outils de détestation de vrais outils ... à l'endroit où j'ai vu, il a été appliqué aux funcitons de C++ et de classe, qui tuent même cet attribut.

Devinez mon avis. :)

5
Balog Pal