Quelques bonnes règles de formatage en C++

Bonsoir,

Je suis en ce moment sur un projet en C++. Et souvent je rencontre des problèmes d'ordre syntaxique. Il m'arrive assez souvent d'avoir des lignes qui dépassent les 80 caractères. Ou bien, étant débutant en C++, je n'aime pas utiliser le mot-clef auto à tout va, voir même utiliser des using trop souvent.

De façon générale, quels sont les règles que vous utilisez pour formater votre code source ? Si vous coupez une ligne, où se fait l'indentation ? Quand est-ce que vous utilisez auto ? Les using ?

Cordialement,

Saroupille

Lu'!

Au feeling, les coupures, le but c'est que soit lisible, je cherche pas vraiment à respecter une règle précise.

Pour chaque variable que je crée avec une dépendance de type. Donc, de base, tous les temporaires déjà. De même quand la création de ma variable est soumise au résultat d'un appel de fonction, j'utilise également auto (exemple typique : make_unique, qui nous annonce la totalité du type). Bref, à moins d'avoir une volonté particulière de forcer un type (appel direct au constructeur, variable de parcours, etc …), j'utilise auto.

(1) ne pas oublier que using peut se limiter à seulement certaines fonctionnalités : using std::vector;

(2) ne pas oublier que using a une portée comme les variables.

A partir de là, j'utilise using quand dans une portée j'utilise une fonctionnalité très souvent et que le namespace où elle se trouve n'a pas de risque de rentrer en conflit avec un autre. Moralité : souvent dans des portées locales.

le formatage du code et l'utilisation de auto/using sont deux problématiques différentes.

Pour le premier : clang-format. Regarde en particulier les fichiers de configuration (google, llvm, etc)

Bonjour,

Quand j'ai des syntaxes trop lourdes sur une ligne, j'ai tendance à éclater au niveau de chaque ,. Que ce soit pour les déclarations de paramètres template, les déclarations de fonctions ou les appels de fonctions :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

template<
  class A,
  class B,
  ...
>

void foo(
  int a,
  int b,
  ...
)

foo(
  a,
  a,
  ...
);

Je dois avouer que je n'aime pas toujours ta façon de présenter tes codes, en particulier pour les templates Probablement une question d'habitude.

Mais il est vrai qu'il est parfois préférable d'écrire une syntaxe sur plusieurs lignes si celle ci est trop longue. (HS : pour un projet, ce n'est généralement pas problématique d'avoir des lignes de plus de 60 ou 80 caractères. Par contre, quand on écrit des articles, on est souvent obligé de limiter la longueur des lignes, pour éviter les barres de défilement horizontale)

Il faut rester souple sur la mise en forme, le principal est que cela reste lisible (il est intéressant de lire les articles de mewtown sur ce sujet). Quelques règles/conseils supplémentaires :

• principe de moindre surprise
• rester compact et lisible
• séparer si possible entre 2 arguments plutôt qu'entre le type et l'identifiant
• regrouper les paramètres qui sont liés ensemble
• rester homogène (entre les fonctions, entre les paramètres d'une même fonction, rester cohérent avec les notions des libs utilisées STL/Qt par exemple)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// bof
f(int
  a, int
  b);

// ok
f(int a,
  int b);

// bof
f(int x1, int y1, 
  int z1, int x2,
  int y2, int z2);

// ok
f(int x1, int y1, int z1,    // point 1
  int x2, int y2, int z2);   // point 2

// bofs
f(int a, int B);
f(int my_var_1, int myVar2);

sort(vector<T> & v);                 // bof, non homogène avec STL
sort(Iterator first, Iterator last); // ok

MyWidget(QWidget *w, int i);     // bof, non homogène avec Qt
MyWidget(int i, QWidget *w = 0); // ok

// bof
if (value == 1)
{
  do_something();
} else if (value == 2)
{
  do_anothing_thing();
}

// ok (regroupement visuels des blocs avec les if correspondant)
if (value == 1) {
  do_something();
} 
else if (value == 2) {
  do_anothing_thing();
}

Bonjour,

1) J'utilise auto partout où le type exact n'est pas tout à fait trivial et principalement pour les types d'itérateurs / pair d'itérateur de la STL. Dernièrement j'ai découvert que la bibliothèque Boost Graph était bien plus accessible et simple d'utilisation grace à auto!

2) Je remplace tous mes typedefs dans mes codes par des using. J'utilise également using pour faire des alias de template. J'utilise beaucoup plus rarement using pour importer des éléments d'un autre namespace dans le namespace courant bien que cela soit pratique en particulier lorsque l'on utilise std::begin, std::end et std::swap ou lorsque l'on souhaite rendre public une fonction membre d'une classe parente héritée de façon privée.