Les bizarreries du langage C

• Récap' communautaire #8 — Octobre 2018
• La revue de code, c'est important !

Le C est un langage à la syntaxe simple. Les seules complexités de ce langage viennent du fait qu’il agit de manière proche de la machine.

Pourtant, une partie des syntaxes autorisées par le C n’est pratiquement jamais enseignée. Attaquons-nous à ces cas mystérieux !

• Les opérateurs inusités
• L'accès à un tableau
• L'initialisation
• Les expressions littéralement composées
• Introduction aux VLAs
• L'exception des VLAs
• Un tableau flexible
• Une histoire d'étiquettes
• Les nombres complexes
• Les macros génériques
• Les caractères trop spéciaux

Les opérateurs inusités

Il existe beaucoup d’opérateurs dans le langage C. Ici, on va parler particulièrement de deux d’entre eux qui ne sont pratiquement jamais utilisés.

L’opérateur virgule

Le premier est l’opérateur virgule. En C la virgule sert à séparer, factoriser les éléments d’une définition ou séparer les éléments d’une fonction. En bref, c’est un élément de ponctuation. Mais pas seulement ! C’est également un opérateur.

L’instruction suivante, bien qu’inutile est tout à fait valide :

printf("%d", (5,3) );

Elle affiche 3. L’opérateur , sert à juxtaposer des expressions. La valeur de l’expression complète est égale à la valeur de la dernière expression.

Cet opérateur se révèle très utile dans une boucle for pour multiplier les itérations. Par exemple pour incrémenter i et décrémenter j dans la même itération d’une boucle for on peut faire :

for( ; i < j ; i++, j-- ) {
 // [...]
}

Ou encore, dans de petits if pour les simplifier :

if( argc > 2 && argv[2][0] == '0' )
    action = 4, color = false;

Ici, on assigne action et color. Normalement pour faire 2 assignations, on aurait dû mettre des accolades au if.

On peut également s’en servir pour retirer des parenthèses.

while( c = getchar(), c != EOF && c != '\n' ) {
  // [...]
}
// Est strictement équivalent à :
while( (c = getchar()) != EOF && c != '\n' ) {
  // [...]
}

Mais surtout, ne pas abuser de cet opérateur ! On peut, de manière assez rapide, obtenir des choses illisibles. Cette remarque est d’ailleurs également valide pour le prochain opérateur !

L’opérateur ternaire

Le ternaire pour les intimes. Le seul opérateur du langage C qui prenne 3 opérandes. Il sert à simplifier des expressions conditionnelles.

Par exemple pour afficher le minimum de deux nombres, sans le ternaire, on ferait :

if (a < b)
    printf("%d", a);
else
    printf("%d", b);

Ou avec une variable temporaire :

int min = a;
if( b < a)
  min = b;
printf("%d", min);

Alors qu’avec les ternaires on fait simplement :

printf("%d", a<b ? a : b);

Grâce au ternaire, on a économisé une répétition ainsi que quelques lignes. Mais surtout on a gagné en lisibilité. Quand on sait en lire une…

Pour lire une expression ternaire, il faut la découper en 3 parties :

expression_1 ? expression_2 : expression_3

La valeur d’une expression ternaire est expression_2 si la valeur de expression_1 est évaluée à vrai et expression_3 sinon.

En somme, cela simplifie un peu la lecture pour de courtes expressions. L’expression a<b ? a : b se lit « Si a est inférieur à b alors a sinon b ».

J’insiste encore sur le fait que cet opérateur, s’il est mal utilisé, peut nuire à la lisibilité du code. Notez que l’on peut très bien utiliser une expression ternaire comme opérande d’une autre expression ternaire :

printf("%d", a<b ? a<c ? a : b<c ? b : c : b < c ? b : c); 

Désormais, on prend le minimum de trois nombres. C’est aéré, mais impossible à suivre. Le plus lisible est d’utiliser une macro :

#define MIN(a,b) ((a) < (b) ? (a) : (b))

printf("%d", MIN(a,MIN(b,c)));

Et voilà ! Deux opérateurs qui vont désormais gagner un peu d’intérêt. Et être mieux compris ! Puis d’ailleurs, même les opérateurs que l’on connait déjà, on n’en maîtrise pas forcément la syntaxe.

L'accès à un tableau

On nous a toujours appris que pour afficher le 3ème élément d’un tableau, on faisait :

int tab[5] = {0, 1, 2, 3, 4, 5};
printf("%d", tab[2]);

2 et non 3, car un tableau en C commence à 0. Si un tableau commence à 0, c’est une histoire d’adresse¹. L’adresse du tableau est en fait l’adresse du premier élément du tableau. Et par arithmétique des pointeurs, l’adresse du 3ème élément est tab+2.

Donc on aurait très bien pu écrire :

printf("%d", *(tab+2));

Puis comme l’addition est commutative, tab+2 ou 2+tab sont équivalents. En fait, on aurait même pu faire :

printf("%d", 2[tab]);

C’est tout à fait valide. Et pour cause : la syntaxe E[F] est strictement équivalente à *((E)+(F)). Du coup, le titre de cette section est un peu trompeur. Cet opérateur n’a pas grand-chose à voir avec les tableaux en fait. C’est du sucre syntaxique pour cacher l’arithmétique des pointeurs.²

Par exemple pour afficher le caractère = pour vrai, ! pour faux et ~ pour aucun des deux. On pourrait faire :

if( is_good == 1 )
  printf("%c", '=');
else if( is_good == 0 )
  printf("%c", '!');
else
  printf("%c", '~');

Mais il existe plus simple :

printf("%c", "!=~"[is_good]);

// Ou comme on l'a vu :
printf("%c", is_good["!=~"] ); // Affiche '!' si is_good vaut 0
                               //         '=' si is_good vaut 1
                               //         '~' si is_good vaut 2

En somme, tout le monde écrit tab[3] et pas 3[tab]. Du coup, il n’y a aucun intérêt à écrire 3[tab]. Mais c’est toujours bon de savoir que ça existe.

L'initialisation

L’initialisation, c’est quelque chose que l’on maîtrise en C. C’est le fait de donner une valeur à une variable lors de sa déclaration. En gros, on définit sa valeur.

Pour un tableau¹ :

int tab[10] = {0};
tab[2] = 5;

À la première ligne, on initialise le tableau avec des 0 car, lorsqu’on initialise un tableau toute valeur non spécifiée est par défaut 0. La ligne suivante est une affectation et non une initialisation.

Si on veut seulement initialiser le troisième élément, puisque l’initialisation d’un tableau se fait suivant l’ordre de ses valeurs, on devrait écrire :

int tab[10] = {0, 0, 5};

Mais en réalité, il existe une autre syntaxe qui permet de faire plus simple :

int tab[10] = {[2] = 5};

On dit simplement que la troisième case vaut 5. Le reste est par défaut 0. Une syntaxe équivalente existe d’ailleurs pour les structures et les unions.

On peut ainsi initialiser un point en utilisant ses composantes.

typedef struct point {
  int x,y;
} point;


point A = {.x = 1, .y = 2};

Ici, il n’y avait pas d’ambigüité. Mais pour une structure plus complexe, cette syntaxe est vraiment avantageuse.

Tenez :

typedef struct message {
   char src[20], dst[20], msg[200];
} message;

// [...]

message to_send = {.src="", .dst="23:12:23", .msg="Code 10"};

// Est bien plus clair que :

message to_send = {"", "23:12:23", "Code 10"};

// D'ailleurs, je ne l'ai pas fait mais avec cette syntaxe pas besoin de se souvenir de l'ordre
// des champs de la structure

message to_send = { .msg="Code 10", .dst="23:12:23", .src=""};

// Et aussi puisque tout champ d'une structure est inialisé à sa valeur nulle s'il n'est pas initialisé explicitement.
// On peut également omettre src.

message to_send = { .dst="23:12:23", .msg="Code 10"};

Avec ces syntaxes on peut également alourdir le code, mais généralement, on gagne en lisibilité. Parfois, ces syntaxes sont très judicieusement utilisées ! Comme ici, dans ce décodeur de base64 :

Les expressions littéralement composées

Puisque nous parlons des tableaux. Il existe une syntaxe simple pour utiliser des tableaux à usage unique.

Je voudrais utiliser ce tableau :

int tab[5] = {5, 4, 5, 2, 1};
printf("%d", tab[i]); // Avec i égale à quelque chose >=0 et <5

Cependant, je ne l’utilise qu’une seule fois ce tableau … C’est un peu dérangeant d’avoir à utiliser un identificateur juste pour ça.

Eh bien je peux faire ceci :

printf("%d", ((int[]){5,4,5,2,1}) [i] ); // Avec i égale à quelque chose >=0 et <5

Ce n’est pas super lisible pour le coup. Mais il existe plein de cas où cette syntaxe est très utile. Par exemple avec une structure :

// Pour envoyer notre message :
send_msg( (message){ .dst="192.168.11.1", .msg="Code 11"} );

// Pour afficher la distance entre deux points
printf("%d", distance( (point){1, 2}, (point){2, 3} )  );

// Ou encore sous Linux, en programmation système
execvp( "bash" , (char*[]){"bash", "-c", "ls", NULL} );

On appelle ces expressions des compound literals (ou littéraux agrégats si l’on s’essaye à traduire).

Introduction aux VLAs

Les tableaux à taille variable (ou Variable Length Arrays en anglais, soit VLAs) sont des tableaux dont la taille n’est connue qu’à l’exécution. Si vous n’avez jamais entendu parler des VLAs, ceci devrait vous choquer :

int n = 11;

int tab[n];

for(int i = 0 ; i < n ; i++)
  tab[i] = 0;

Ce code, bien que valide, a dû être réprimandé par de nombreux professeurs. En effet, on nous apprend qu’un tableau doit avoir une taille connue à la compilation. Eh bien, les VLAs constituent l’exception. Apparu avec la norme C99, les VLAs jouissent d’une mauvaise réputation. À cela, il existe plusieurs raisons que je ne détaillerais pas ici¹. Je vais simplement parler des comportements non-intuitifs introduits avec les VLAs. Mais tout d’abord, voyons ce qu’est et comment se servir d’un tableau à taille variable.

Les VLAs se définissent avec la même syntaxe qu’un tableau classique. La seule différence est que la taille du tableau est une expression entière non constante.

int n = 50;
int tab[n];

double tab2[2*n];

unsigned int tab[foo()]; // avec foo une fonction définie ailleurs

Un VLA ne peut pas être initialisé, de plus, il ne peut être déclaré static. C’est-à-dire que ces deux déclarations sont incorrectes :

int n = 30;

int tab[n] = {0};
static tab2[n];

Dans une fonction, on pourrait utiliser :

void bar(int n, int tab[n]) {

}

Cependant, la taille de la première dimension d’un tableau n’a pas beaucoup d’importance, un tableau étant implicitement convertit en un pointeur vers son premier élément. En revanche, pour un tableau à deux dimensions, la taille de la deuxième dimension doit être spécifiée :

void foo( int n, int m, int tab[][m]) {

}

À noter qu’il est possible d’utiliser le caractère * (encore une utilisation de plus) en lieu et place de la taille d’une ou plusieurs dimensions d’un VLA, mais uniquement au sein d’un prototype.

void foo(int, int, int[][*]);

Bien, après cette courte introduction aux VLAs, passons aux cas qui nous intéressent. Pour être précis, les bizarreries et excentricités que les VLAs ont introduits.

L'exception des VLAs

Le comportement déviant le plus connu des VLAs est leur rapport à sizeof.

sizeof est un opérateur unaire qui permet de retrouver la taille d’un type à partir d’une expression ou du nom d’un type entouré de parenthèses.

/*  Le fonctionnement de l'opérateur sizeof par des exemples */ 
float a;
size_t b = 0;

printf("%zu", sizeof(char)); // Affiche 1
printf("%zu", sizeof(int));  // Affiche 4
printf("%zu", sizeof a);     // Affiche 4
printf("%zu", sizeof(a*2.)); // Affiche 8
printf("%zu", sizeof b++);   // Affiche 8

Le premier résultat n’est pas très surprenant, la taille d’un char est défini à 1 byte et sizeof(char) doit retourner 1. Le deuxième résultat est la taille d’un int¹. Le troisième résultat est la taille d’un float¹. Le quatrième est la taille d’un double¹ qui est le type de l’expression a*2.². Le dernier résultat est la taille d’un size_t¹, size_t étant le type de l’expression b++.

Ici, je ne me suis pas intéressé à la valeur des expressions et pour cause, sizeof ne s’y intéresse pas non plus. Ces valeurs sont déterminées à la compilation. Les opérations que l’on retrouve dans l’expression passé à sizeof ne sont pas effectuées. Puisque l’expression doit être valide, son type doit être déterminé à la compilation. Le résultat de sizeof étant alors connu à la compilation, il n’y avait aucune raison d’exécuter l’expression.

int n = 5;
printf("%zu", sizeof(char[++n])); // Affiche 6

Arf ! Les VLAs rajoutent leur grain de sel. Dans le type int[++n], ++n est une expression non constante. Donc le tableau est un tableau à taille variable. Pour connaitre la taille totale du tableau, il est nécessaire d’exécuter l’expression entre crochet. Ainsi n vaut désormais 6 et sizeof nous indique qu’un VLA de char déclaré avec cette expression aurait eu pour taille 6.

Ce n’est que peu intuitif puisque les VLAs ont ici introduit une exception à la règle qui est de ne pas exécuter l’expression passée à sizeof.

Un autre comportement bizarre introduit par les VLAs est l’exécution des expressions liées à la taille d’un VLA dans la définition d’une fonction. Ainsi :

int foo( char tab[printf("bar")] ) {
   printf("%zu", sizeof tab);
}

En supposant que les affichages ne causent pas d’erreur, appeler cette fonction affichera bar3. L’instruction printf("bar") est évaluée et ensuite seulement le corps de la fonction est exécuté.

Il est à noter qu’il existe d’autres exceptions induites pas la standardisation des VLAs comme l’impossibilité d’allouer les VLAs de manière statique (assez logique), ou l’impossibilité d’utiliser des VLAs dans une structure (GNU GCC le support tout de même). Et même certains branchements conditionnels sont interdits lorsque l’on utilise un VLA.

Un tableau flexible

Vous n’avez peut-être jamais entendu parler des « flexible arrays member ». C’est normal, ceux-ci répondent à une problématique très précise et peu courante.

L’objectif est d’allouer une structure mais dont un champ (un tableau) est de taille inconnue à la compilation et le tout sur un espace contiguë¹.

Ici, pas de VLAs, car comme on l’a vu, ceux-ci sont interdits en tant que champs de structure. L’allocation dynamique s’impose.
On pourrait vouloir faire :

struct foo {
  int* tab;
};

Et l’utiliser comme ceci :

  struct foo* contigue = malloc( sizeof(struct foo) );
  if (contigue) {
    contigue->tab = malloc( N * sizeof *contigue->tab );
    if (contigue->tab) {
      contigue->tab[0] = 11;
    }
  }

Mais ici, le tableau n’a aucune raison d’être contiguë à la structure. Ce qui aura pour conséquence qu’en cas de copie de la structure, la valeur du champ tab sera la même pour la copie et l’origine. Pour éviter cela, il faudra copier la structure, réallouer le tableau et le recopier. Voyons une autre méthode.

struct foo {
  /* ... Au moins un autre champ car le standard l'impose. */
  int flexiTab[];
};

Ici, le champ flexiTab est un tableau membre flexible. Un tel tableau doit être le dernier élément de la structure et ne pas spécifier de taille². On l’utilise comme ceci :

  struct foo* contigue = malloc( sizeof(struct foo) + N * sizeof *flexiTab );
  if (contigue) {
    flexiTab[0] = 11;
  }

Cette syntaxe répond autant à un besoin de portabilité sur les architectures imposant un alignement particulier (le tableau est contigu à la structure) qu’au besoin de faire apparaître un lien sémantique entre le tableau et la structure (le tableau appartient à la structure).

Une histoire d'étiquettes

En C, s’il y a un truc dont on ne doit pas parler, ce sont bien des étiquettes. On les utilise avec la structure de contrôle goto ! L’interdite !

Pour les cacher, on remplace les goto par des structures de contrôles adaptées et plus claires comme break ou continue. De manière à ne jamais avoir à utiliser goto.

Du coup, on n’apprend jamais ce qu’est une étiquette…

Voici comment on utilise goto et une étiquette :

goto end;


end: return 0;
}

En gros, une étiquette est un nom que l’on donne à une instruction.

Eh bien on en utilise des étiquettes ! Dans les switch !

switch( action ) {
    case 0:
        do_action0();
    case 1:
        do_action1();
        break;
    case 2:
        do_action2();
    break;
    default:
        do_action3();
}

Ici, les case et le default sont en fait des étiquettes ! Comme pour les goto. Sauf qu’elles sont pour les switch, et inutilisables par les goto…

Déjà, c’est bien de savoir que ça s’appelle une étiquette. Ensuite, parce que je vais vous parlez d’un classique. Le dispositif de Duff.

C’est une sorte de boucle déroulée optimisée. Le but est de réduire le nombre de vérifications de fin de boucle (ainsi que le nombre de décrémentations).

Voici la version historique écrite par Tom Duff :

{
    register n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
            } while (--n > 0);
    }
}

Peu importe ce que signifie register. Aussi, to est un pointeur particulier, mais ce n’est pas vraiment important.

Ici, ce dont je veux vous parler, c’est de cette boucle do-while en plein milieu d’un switch.

Le test que l’on cherche à effectuer le moins possible est --n > 0.

En temps normal, n serait en fait count. Et on devrait faire le test count fois. De même pour sa décrémentation.

C’est-à-dire :

while( count-- > 0 )
    *to = *from++;

En divisant par 8 (nombre arbitraire) on divise également par 8 le nombre de tests et de décrémentations. Cependant, si count n’est pas divisible par 8, on a un problème, on ne fait pas toutes les instructions. Ce serait bien de pouvoir sauter directement à la 2ème instruction, si on a seulement 6 instructions restantes.

Et c’est là que les étiquettes peuvent nous aider ! Grâce au switch on peut sauter directement à la bonne instruction.

Il suffit d’étiqueter chaque instruction avec le nombre d’instructions qu’il reste à faire dans la boucle. Puis de sauter dans la boucle avec la structure de contrôle switch sur le reste d’instructions à réaliser.

Ensuite, on exécute nos paquets de 8 instructions normalement.

Il est très rare d’avoir à utiliser ce type d’astuce. D’ailleurs, c’est une optimisation d’un autre temps. Mais comme je voulais vous parler de syntaxe, il était nécessaire de parler des étiquettes.

Les nombres complexes

Encore une fois nous allons voir une syntaxe introduite en C99. Plus exactement, ce sont 3 types qui ont été introduits, ceux-ci correspondent aux nombres complexes. Le type d’un nombre complexe est double _Complex (les deux autres types suivent le même schéma, afin de ne pas me répéter, je vais me concentrer sur le type double).

Ainsi en C, il est possible de déclarer un nombre complexe comme ceci :

double complex point = 2 + 3 * I;

Ici, on retrouve les macros spéciales complex et I (définie dans l’en-tête <complex.h>). Le premier sert à créer un type complexe alors que le second sert à définir la partie imaginaire d’un nombre complexe.

En mémoire une variable complexe occupe autant d’espace que 2 fois le type réel sur lequel elle est basée. On se sert d’une variable complexe comme d’une variable normale. L’arithmétique y est intuitive puisque basées sur celle des réels. Il est à noter qu’il est recommandé d’utiliser le macro CMPLX pour initialiser un nombre complexe :

double complex cplx = CMPLX(2, 3);

Pour une meilleure gestion des cas où la partie imaginaire (celle multipliée par I donc) serait NAN, INFINITY ou encore plus ou moins 0.

L’en-tête <complex.h> nous offre une manière réellement simple d’utiliser des nombres imaginaires. En effet, de nombreuses fonctions courantes de manipulations des nombres imaginaires y sont disponibles.

Les macros génériques

Il existe un moyen en C d’avoir des macros qui soient définies différemment en fonction du type de l’un de ses arguments. Cette syntaxe est cependant « nouvelle » puisqu’elle date du standard C11.

Cette généricité s’obtient avec les sélections génériques basées sur la syntaxe _Generic ( /* ... */ )

Pour comprendre la syntaxe, voyons un exemple simpliste :

#include <stdio.h>
#include <limits.h>

#define MAXIMUM_OF(x) _Generic ((x), \
                                char: CHAR_MAX, \
                                int:  INT_MAX,  \
                                long: LONG_MAX  \
                                )

int main(int argc, char* argv[]) {
    int i = 0;
    long l = 0;
    char c = 0;

    printf("%i\n", MAXIMUM_OF(i));
    printf("%d\n", MAXIMUM_OF(c));
    printf("%ld\n", MAXIMUM_OF(l));
    return 0;
}

Ici, on affiche le maximum que peut stocker chacun des types que nous utilisons. C’est quelque chose qui n’aurait pas été possible sans l’utilisation de ce nouveau mot-clé _Generic. Pour utiliser cette syntaxe, on utilise le mot clé _Generic auquel on passe 2 paramètres. Le premier est une expression dont le type va influencer l’expression finalement exécutée. Le deuxième est une suite d’association de type et d’expression (type : expression) dont les associations sont séparées par des virgules. Au final, seule l’expression désignée par le type de la première expression est finalement évaluée.

Un exemple réel d’utilisation pourrait être :

int powInt(int,int);

#define POW(x,y) _Generic ((y), double: pow, float: powf, long double: powl, int: powInt)((x), (y))

Il n’y a plus grand-chose à dire si ce n’est qu’il est possible d’avoir dans la liste des types le mot default qui correspondra alors à tous les types non-cités. Ainsi une définition plus propre de la macro POW de tout à l’heure pourrait être :

int powIntuInt(int a, unsigned int b);
double powIntInt(int a, int b);
double powFltInt(double a,int b) { return pow (a,b); }
double powfFltInt(float a,int b) { return powf(a,b); }
double powlFltInt(long double a,int b) { return powl(a,b); }


#define POWINT(x) _Generic((x), double: powFltInt,          \
                                float : powfFltInt,         \
                                long double: powlFltInt,    \
                                unsigned int: powIntuInt,   \
                                default: powIntInt)
#define POW(x,y) _Generic ((y), double: pow, float: powf, long double: powl, default: POWINT((x)) )((x), (y))

Les caractères trop spéciaux

On va remonter encore dans le temps. Je vais vous citer une dernière chose. Un temps où tous les caractères n’étaient pas aussi accessibles que de nos jours sur autant de types de claviers.

Les claviers n’avaient pas forcément de touches de composition. Ainsi, il était impossible de taper le caractère #.

On pouvait alors remplacer le caractère # par la séquence ??=. Et pour chaque caractère n’étant pas sur le clavier et utiliser en langage C, il existait une séquence à base de ?? que l’on nomme trigraphe. Une autre version à base de 2 caractères plus lisible se nomme les digraphes.

Voici un tableau récapitulatif des séquences de trigraphes, de digraphes et de leur représentation en caractère.

La différence principale entre les digraphes et les trigraphes est dans une chaîne de caractère :

puts("??= est un croisillon");
puts("%:");

Ces mécanismes du Moyen Âge sont encore valides de nos jours en C. Du coup, cette ligne de code est tout à fait valide :

??=define FIRST tab<:0]

La seule utilité de cette syntaxe de nos jours est d’obfusquer un code source très facilement. Une combinaison d’un ternaire avec un trigraphe et un digraphe et vous avez un code absolument illisible.

printf("%d", a ?5??((tab):>:0);

À ne jamais utiliser dans un code sérieux donc.

Voilà, c’est fini, j’espère que vous avez appris quelque chose de ce billet. Surtout n’oubliez pas d’utiliser ces syntaxes avec parcimonie.

Je tiens tout particulièrement à remercier Taurre pour avoir validé cet article, mais également pour sa pédagogie sur les forums depuis des années, ainsi que blo yhg pour sa relecture attentive.

À noter que vous pouvez (re)découvrir de nombreux codes abusant de la syntaxe du langage C aux IOCCC.

• Récap' communautaire #8 — Octobre 2018
• La revue de code, c'est important !