Fiche

 informatique  –  programmation  en  C  

 
 

«  Coding  Style  »  -­  conventions  de  codage  

 

1.   «  coding  style  »  ? .........................................................................................................................................................1  

2.   Ecrire  des  fonctions  courtes  ;  limiter  la  taille  des  modules .....................................................................2  
3.   Nombre  de  caractères  par  ligne ...........................................................................................................................2  
4.   Indentation  du  code...................................................................................................................................................2  
5.   Conventions  de  nommage.......................................................................................................................................3  
6.   Commentaires  du  code.............................................................................................................................................4  
 

1. «  coding  style  »  ?  
La  notion  de  conventions  de  codage  (coding  style)  désigne  un  ensemble  de  règles  et  de  conseils  
adoptés  par  les  membres  d’un  projet  logiciel  pour  écrire  et  mettre  en  forme  du  code.  

Les  conventions  de  codage  visent  essentiellement  à  améliorer  la  lisibilité  du  code  :  elles  doivent  
permettre  au  programmeur  d’identifier  «  du  premier  coup  d’œil  »  un  maximum  de  choses  dans  
le   code,   de   se   repérer   facilement,   de   savoir   ou   trouver   les   choses,   etc.   Une   fois   adoptés,   elles  
facilitent  grandement  l’écriture,  la  maintenance  et  aident  à  éviter  certaines  erreurs.  

Dès   lors   qu’on   travaille   sur   un   projet   logiciel   d’une   certaine   ampleur,   qui   plus   est   à  
plusieurs,   l’expérience   montre   qu’il   est   très   important   de   se   mettre   d’accord   sur   les  
conventions  de  codage.    

Les   standards   du   langage   C   ne   spécifient   pas   de   convention   de   codage   (à   l’inverse   d’autres  

langages,   par   exemple   au   Java1)  :   chaque   projet   logiciel   (chaque   équipe)   doit   faire   son   choix.  
Suivant  le  projet,  on  pourra  bien  sûr  aller  plus  ou  moins  loin  dans  les  conventions  adoptées.  

En  conséquence,  cette  fiche  ne  propose  pas  de  conventions  de  codage  «  prêtes  à  l’emploi  »  ;  elle  
vise  plutôt  à  :  

-­‐ lister  les  principaux  éléments  qu’on  retrouve  très  régulièrement  dans  les  conventions  de  
codage  

-­‐ sur  chacun  d’eux,  le  cas  échéant,  donner  des  exemples  de  choix  possibles.  

Vous   pouvez   en   complément   vous   inspirer   de   conventions   d’usage   courant  ;   en   la   matière,   le  

«  coding  style  »  du  noyau  du  système  d’exploitation  GNU/Linux,  à  la  fois  simple  et  assez  complet,  
constitue  un  bon  point  d’entrée2.  

Enfin,   il   se   peut   que   le   projet   logiciel   sur   lequel   vous   travaillez   actuellement   impose   déjà   des  
conventions,  auquel  cas  vous  devez  vous  y  conformer.    

                                                                                                                         
1  [Link]  

2  Linus  Torvalds.  Linux  Kernel  Coding  Style.  [Link]    

 
Fiche  informatique  –  programmation  en  C  
 
 

2. limiter  la  taille  des  modules.  Ecrire  des  fonctions  courtes  et  simples  
Pour  être  lisible  et  compréhensible,  un  élément  structurant  le  code  doit  être  suffisamment  court.  
Les   conventions   de   codage   limitent   donc   la   taille   des   fonctions   (en   nombre   de   lignes   et/ou  
nombre   de   niveau   d’indentation,   etc.)   et   la   taille   des   modules   (en   nombre   de   ligne   et/ou   nombre  
de  fonctions).  

Si   une   fonction   ou   un   module   devient   trop   long,   c’est   que   son   «  savoir   faire  »   est   sans   doute   trop  
large  et  mal  défini  ;  découper  la  fonction  en  sous  fonctions  plus  simples,  ou  découper  le  module  
en  plusieurs  modules  plus  simples,  permet  de  clarifier  le  rôle  de  chaque  fonction  ou  module.  

Des  choix  assez  courant  sont  :  

-­‐ pas  plus  de  50  ou  100  lignes  de  code  pour  une  fonction  

-­‐ pas  plus  d’un  millier  de  lignes  pour  le  fichier  source  .c  d’un  module  

3. Nombre  de  caractères  par  ligne  

Pour   que   le   code   puisse   être   imprimé   et   lu   sur   un   écran   standard,   il   faut   limiter   le   nombre   de  
caractères  par  ligne.  Un  choix  courant  est  80  ou  100  caractères  maximum.  

4. Indentation  du  code  

Indenter   le   code,   c’est   introduire   à   bon   escient   des   espaces   ou   des   tabulations   au   début   des  
lignes,   notamment   pour   faire   ressortir   les   blocs   de   code   (entre   { }),   donc   en   particulier  :   le  
corps  des  fonctions,  les  structures  de  contrôles  (conditionnelles,  boucles…).    

Indenter  le  code  est  indispensable  à  sa  lisibilité.    

A  titre  d’exemple,  considérons  les  deux  codes  suivants.  Les  deux  sont  parfaitement  équivalents  
pour  le  compilateur.  Lequel  est  le  plus  lisible  ?  

 
 
Comme  pour  toutes  les  autres  conventions  de  codage,  il  existe  plusieurs  principes  pour  
l’indentation.  Insistons  brièvement  sur  les  choses  essentielles  :  
-­‐ Une  seule  unique  instruction  par  ligne  (un  seul  «  ;  »).  Passer  à  la  ligne  pour  l’instruction  
suivante.  

 
Fiche  informatique  –  programmation  en  C  
 
 

-­‐ Le  contenu  d’un  nouveau  bloc  doit  avoir  un  niveau  d’indentation  en  plus  (décalé  vers  la  
droite)  
-­‐ L’accolade  fermant  le  bloc  est  alignée  immédiatement  en  dessous  du  début  de  
l’instruction  qui  a  déclenché  l’ouverture  le  bloc  

On  donne  ci  dessous  quelques  exemples.  

for( i=1; i < n; i++ )  
{ for( i=1; i < n; i++ ) {
if(t[i] < min ) if(t[i] < min ) {
{ min = t[i];
min = t[i]; }
} }  
}
A  droite,  on  ouvre  l’accolade  sans  aller  à  la  ligne.  C’est  OK  aussi,  et  on  gagne  une  ligne.  Dans  les  
deux  cas,  l’accolade  fermant  le  bloc  est  alignée  avec  l’instruction  qui  provoque  son  ouverture  (for  
et  if  respectivement).  

Un  autre  exemple  :  
#include <stdio.h>
int main(int argc, char *argv[])
{
int i ; /* déclaration de variables… */
float x ;

if(argc != 2) {
printf(stderr, "Erreur : nb args\n") ;
return EXIT_FAILURE;
}

if( strcmp(argv[1], "-h") == 0) {

printf("Aide : blabla\n") ;
} else if( strcmp(argv[1], "-b") == 0) {
printf("Option -b\n") ;
} else {
printf(stderr, "Erreur : arg non reconnu\n") ;
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}

Plus   généralement,   les   exemples   des   fiches   pédagogiques   sont   correctement   indentés   –   avec  
diverses  conventions.  

5. Conventions  de  nommage  

Les   conventions   de   nommage   indiquent   comment   choisir   les   noms   des   identifieurs  :   types,  
constantes,  fonctions,  paramètres  des  fonctions,  variables.    

Quatre  grands  principes  sont  :  

-­‐ choisir  des  noms  signifiants,  qui  indiquent  ce  qu’est  la  chose  nommée.  Il  vaut  mieux  
des  noms  longs  et  clairs  que  courts  mais  abscons.  
-­‐ Eviter  les  noms  trop  courts  et  trop  longs.  
-­‐ Séparer   les   mots   dans   un   nom.   Deux   choix   possible  :   majuscule   ou   underscore   «  _  ».  
Exemple  :  ceciEstUneVariable  ou  ceci_est_une_variable.  

 
Fiche  informatique  –  programmation  en  C  
 
 

-­‐ Se  mettre  d’accord  sur  un  moyen  permettant  de  repérer  immédiatement  si  un  identifieur  
est   un   type,   une   constante   #define,   une   variable,   un   paramètre,   une   fonction,   un  
pointeur,  etc.  

Les  variations  sont  très  nombreuses.  Quelques  exemples  suivent.  

Types  
Ajouter  _t  à  la  fin.  Exemple  :          typedef float MesFloat_t ;  

Constantes  #define  
En  majuscule,  mots  séparés  par  «  _  ».  Exemple  :   #define MAX_CHAR 1024  

Variables  et  fonctions  

Minuscule  pour  le  premier  mot,  majuscule  ensuite.    
Exemple  :             float sommeDesTermes ;  

Variable  pointeurs  
Il  est  bon  de  repérer  qu’une  variable  est  un  pointeur,  par  exemple  avec  p_.  
Exemple  :             int * p_  

Variable  pointeurs  –  vers  –  tableau  

Il  est  bon  de  distinguer  les  pointeurs  vers  tableau,  par  exemple  avec  t_  ou  tab_  
Exemple  :             int tabTermes ;  

Variables  globales  
Il  est  bon  de  distinguer  les  variables  globales  des  variables  locales,  par  exemple  avec  _g.  
Exemple  :             int uneVarGlobale_g ;  

Etc.  

6. Commentaires  du  code  

Commenter  le  code  est  tout  un  art.    

Quelques  conseils  :  

-­‐ Un  code  non  commenté  ou  un  code  trop  commenté,  c’est  le  mal.  

-­‐ Commenter  le  code  pendant  l’écriture  du  code  (après,  c’est  trop  tard).  

-­‐ Commenter  tout  ce  qui  gagne  à  l’être,  pas  ce  qui  est  clair  sans  commentaire  

-­‐ Ajouter  un  commentaire  avant  chaque  fonction  précisant  le  contrat  de  la  fonction  

-­‐ En  règle  général,  indiquer  dans  les  commentaires  ce  que  fait  le  code,  pas  comment  il  le  
fait  (le  code  doit  être  suffisamment  clair  pour  que  le  «  comment  »  se  lise  tout  seul).  

Enfin,   rappelons   que   des   utilitaires,   tels   que   Doxygen,   sont   à   même   de   générer   une  
documentation  HTML  du  code  à  partir  de  balises  placées  dans  les  commentaires.