Les nouveautés du C99

Cette macro permet de connaître la norme utilisée :

• en C89 elle n'est pas définie ;
• en C94 elle vaut 199409L ;
• et maintenant, en C99, 199901L.

Cette fonctionnalité permet de définir des macros dont le nombre des arguments peut être différent d'un appel à l'autre. La notation utilisée est la même que pour les fonctions ('…') et la liste est récupérée grâce à la macro __VA_ARGS__ :

#define print_error(s, ...) fprintf (stderr, (s), __VA_ARGS__)

Les commentaires « à la C++ », c'est-à-dire commençant par // et se terminant à la fin de la ligne viennent s'ajouter aux commentaires classiques (/* */).

Cette directive du préprocesseur permet de modifier le numéro de la ligne courante (et optionnellement le nom du fichier). La valeur utilisée était limitée à 2¹⁵-1 en C90 et passe maintenant à 2³¹-1.

La directive #pragma permet de contrôler le comportement du compilateur. La norme C99 définit trois pragma standards :

• FP_CONTRACT : optimisation des expressions flottant ;
• FENV_ACCESS : notre programme accède aux paramètres du FPU (Floating Point Unit ou unité de calcul flottant), ceci se fait à l'aide des fonctions déclarées dans fenv.h. Le compilateur doit donc respecter la norme pour les opérations sur les nombres flottant ;
• CX_LIMITED_RANGE : dans le cas d'opérations sûres avec les nombres complexes (c'est-à-dire sans risque de débordement de capacités), vous pouvez le signaler afin d'accélérer le traitement en activant ce pragma.

Chacune de ces fonctionnalités peut être activée (ON), désactivée (OFF) ou remise à son état par défaut (DEFAULT). Par exemple, voici comment activer les optimisations des expressions flottant :

#pragma STDC FP_CONTRACT ON

Le C99 ajoute cinq mots réservés au langage :

• restrict
• inline
• _Complex
• _Imaginary
• _Bool

Les séquences d'échappement à deux caractères permettent de remplacer certains caractères spéciaux qui peuvent être absents du clavier (comme les séquences d'échappement à trois caractères). Avant tout traitement, les lexèmes <:, :>, <%, %>, %: et %:%: sont respectivement remplacés par [, ], {, }, # et ##.

En C90, les déclarations doivent être faites au début d'un bloc, alors qu'en C99 il est tout à fait possible d'écrire :

int main (void)
{
   printf ("Debut du code\n");
   int i = 10;
   printf ("i vaut %d\n", i);
   return 0;
}

Cependant ce genre de mélange n'est pas recommandé afin de préserver la lisibilité du code.
Cette fonctionnalité entraîne la possibilité de créer une variable de boucle temporaire pour l'instruction for :

for (int i = 0; i < 10; i++)
{
    /* variable i utilisable */
}
/* variable i inexistante */

Est équivalent à :

{
   int i;

   for (i = 0; i < 10; i++)
   {
      /* variable i utilisable */
   }
}
/* variable i inexistante */

Par conséquent, la variable i n'existera plus à la sortie de la boucle.

Il est possible d'initialiser les membres d'une structure, lors de sa déclaration, en utilisant leurs noms :

struct T
{
   int a;
   int b;
};

struct T s1 = {.a = 0, .b = 1};
/* ou dans le cas d'un tableau de structure : */
struct T s2[] = {[0].a = 0, [0].b = 0, [1].a = 1, [1].b = 1};

De plus, pour les structures de type auto, il est possible d'initialiser les membres avec des valeurs non connues au moment de la compilation :

int i = 0;
struct T s1 = {.a = i, .b = i+2};

Le mot-clé inline est un nouvel attribut pour les fonctions qui ont pour but de remplacer le système de macro défini grâce à la commande du préprocesseur #define. Pour illustrer l'avantage de cette méthode par rapport aux macros, voici l'exemple classique du calcul du carré d'un nombre :

#define carre(a) ((a)*(a))

Si par malheur vous oubliez les parenthèses autour de la variable a, la macro peut produire un résultat inattendu, il faut aussi faire attention aux effets de bord puisque la variable a est évaluée deux fois. Maintenant avec le mécanisme de fonction en ligne :

inline int carre (int a)
{
   return a*a;
}

int main (void)
{
   int b = carre (5);

   printf ("Le carre de 5 est %d\n", b);
   return 0;
}

Ceci supprime les dangers liés à l'utilisation de l'instruction #define. Les fonctions en ligne doivent être définies aux mêmes endroits que les macros classiques, ce qui peut alourdir les fichiers d'en-tête et surtout recopie la fonction dans plusieurs fichiers sources : pour éviter de se retrouver avec plusieurs fonctions globales portant le même nom, il est conseillé de toujours utiliser le mot-clé inline conjointement avec le mot-clé static (même dans un fichier d'en-tête).

Le nouveau type d'entier long long (signé ou non) est représenté sur au moins 64 bits. Il s'accompagne des notations LL (ou ll) et ULL (ou ull).

La variable __func__(3) contient le nom de la fonction courante. Elle est déclarée ainsi :

static const char __func__[];

En C90, en l'absence de type de retour, le compilateur considère que cette fonction retourne un int, en C99 ce n'est plus possible : le type de retour doit être spécifié.

Le mot-clé restrict permet de spécifier qu'un pointeur est le seul à pointer sur une zone mémoire. Cela permet au compilateur d'opérer certaines optimisations. Par exemple, la fonction memcpy qui est utilisée pour copier deux zones de mémoires qui ne se chevauchent pas peut avoir comme prototype, en C99 :

void *memcpy (void *restrict dst, const void *restrict src, size_t size);

Le mot-clé se place entre le caractère * et le nom du pointeur.

Voilà une fonctionnalité qui va réjouir les réfractaires à l'utilisation des fonctions d'allocation dynamique. En effet, en C90 pour déclarer un tableau, sa taille doit être connue à la compilation. Le C99 propose un mécanisme nommé VLA (Variable-Length Arrays), qui permet de créer des tableaux dont la taille n'est connue qu'à l'exécution. Voici un exemple :

void foo (int n)
{
  int tab[n];
  ...
}

Comme toutes variables automatiques, elles sont détruites à la fin du bloc dans lequel elles sont déclarées (plus de fuites mémoires avec ce système), en contrepartie l'allocation dynamique reste indispensable pour retourner l'adresse d'une zone mémoire.

On peut aussi déclarer un tableau de taille variable dans le prototype d'une fonction :

void foo (int n, int a[n]) { ... }

Il faut que la variable n soit définie avant, ce qui interdit d'écrire ceci :

void foo (int a[n], int n) { ... }

La déclaration d'une telle fonction peut s'écrire :

/* Declaration complete */
void foo (int n, int a[n]);
/* Declaration partielle */
void foo (int n, int a[*]);

Malgré le warning de gcc, le code fonctionne comme prévu.
Ce mécanisme très puissant a tout de même certaines limitations.

• Les tableaux de tailles variables sont limités au fichier, il n'est pas possible d'utiliser le mot-clé extern :

   

  Sélectionnez

  extern int n;
  int a[n]; /* n est declaree extern : utilisation interdite */
  extern int b[n]; /* utilisation interdite */

• Il n'est pas possible de créer de tel tableau static. Par contre il est possible de déclarer static un pointeur sur VLA :

   

  Sélectionnez

  int b[10];
  
  int foo (int n)
  {
    static int a[n]; /* Interdit */
    static (*p_b)[n] = &b; /* Authorise si n == 10 */
  }

  Déclarer un pointeur dur un VLA d'une taille différente de celle autorisée ne stoppe pas l'exécution du programme (on pourrait s'attendre à la levée d'une exception ou quelque chose approchant), mais bien sûr ce genre de manipulation est très risquée et est à classer dans les comportements indéfinis.

• Il n'est pas possible de déclarer un tableau de taille variable dans une structure ou une union.

• Il n'est pas possible d'effectuer un saut dans un bloc qui contient une déclaration de ce type de tableau, par contre sortir de ce bloc est autorisé :

goto start; /* Interdit */
{
  int n = 10;
  int a[n];

start :
  /* ... */
  goto end; /* Authorise */
}
end :
/* ... */

Lors de la déclaration d'une structure, il est possible de ne pas spécifier la taille d'un tableau, s'il s'agit du dernier membre de la structure :

struct incomplet
{
  int n;
  int tab[];
};

Cela permet de faire de belles choses comme ceci :

#include <stdio.h>
#include <stdlib.h>

struct incomplet
{
  int n;
  int tab[];
};

int main (void)
{
  struct incomplet *a = NULL;

  a = malloc (sizeof (*a) + 3 * sizeof (int));
  if (a)
  {
    a->n = 3;
    for (int i = 0; i < a->n; i++)
    {
      a->tab[i] = i;
    }
    printf ("a->tab = { ");
    for (int i = 0; i < a->n; i++)
    {
      printf ("%d, ", a->tab[i]);
    }
    printf (" };\n");
    free (a), a = NULL;
  }

  struct incomplet *b = NULL;

  b = malloc (sizeof (*b) + 5 * sizeof (int));
  if (b)
  {
    b->n = 5;
    for (int i = 0; i < b->n; i++)
    {
      b->tab[i] = i;
    }
    printf ("b->tab = { ");
    for (int i = 0; i < b->n; i++)
    {
      printf ("%d, ", b->tab[i]);
    }
    printf (" };\n");
    free (b), b = NULL;
  }
  return 0;
}

gege2061@debian:~/c99$ gcc -Wall -std=c99 main.c && ./a.out
a->tab = { 0, 1, 2,  };
b->tab = { 0, 1, 2, 3, 4,  };

Cela évite d'utiliser un pointeur pour tab et d'avoir une allocation supplémentaire à faire. Hélas il n'est pas possible de faire :

struct incomplet a = {3, 0, 1, 2};
struct incomplet b = {5, 0, 1, 2, 3, 4};

Un enrichissement de la bibliothèque standard, s'accompagne logiquement de nouveaux fichiers d'en-tête :

• complex.h ;
• fenv.h ;
• inttypes.h ;
• iso646.h ;
• stdbool.h ;
• stdint.h ;
• tgmath.h ;
• wchar.h ;
• wctype.h.

En C, la taille des types de variables n'est pas définie par la norme, seule une taille minimale est garantie. Le C99, dans le fichier d'en-tête stdint.h propose des types dont la taille est connue :

En C90 il n'était pas possible d'utiliser de caractères spécifiques d'une langue (par exemple, les caractères accentués pour le français), et ce, même dans les commentaires. Pour pallier ce problème, la norme C99 propose un nouveau type de caractères étendus nommés wchar_t (pour wide char) défini dans wchar.h. Pour convertir un caractère étendu en entier, le type int peut ne pas être suffisant, à la place, il faut utiliser le type wint_t.
Toutes les fonctions de manipulation des chaînes de caractères (de la forme str*) sont reprises sous la forme wcs* (par exemple wcslen, wcscmp ou encore wcscpy) ainsi que les fonctions wprintf et wscanf pour l'affichage et la saisie formatée de chaînes de caractères étendues.

Le fichier d'en-tête stdarg.h contient une nouvelle fonction va_copy qui permet de copier un objet de type va_list.

Un booléen est un nouveau type de variable qui peut prendre uniquement la valeur vrai ou faux. La définition du type bool est faite dans le fichier d'en-tête stdbool.h et contient les définitions suivantes :

• bool : le type booléen ;
• true : la valeur vrai ;
• false : la valeur faux ;
• __bool_true_false_are_defined : si cette macro est définie, les valeurs bool, true et false le sont aussi.

Les nombres complexes font leurs entrées dans le langage C grâce au type complex défini dans complex.h. Comme il existe trois représentations pour les nombres réels, il existe trois types de nombres complexes :

float complex
double complex
long double complex

Pour construire un nombre complexe, il suffit d'additionner sa partie réelle et sa partie imaginaire :

double partie_reelle = 2.0;
double partie_imaginaire = 3.0;
double complex z = partie_reelle + partie_imaginaire * I;

La macro I permet de construire la partie imaginaire.
Pour retrouver les parties réelles et imaginaires d'un complexe, on peut utiliser, respectivement les fonctions creal et cimag définies pour les trois types de complexes :

float crealf (float complex z);
double creal (double complex z);
long double creall (long double complex z);

float cimagf (float complex z);
double cimag (double complex z);
long double cimagl (long double complex z);

La bibliothèque standard du C99 propose aussi des fonctions pour calculer le module (cabs*), l'argument (carg*) et la représentation selon la projection sur la sphère de Riemann (cproj*) d'un nombre complexe.

C'est sûrement dans ce domaine que les nouveautés sont les plus nombreuses, puisque le C99 introduit la notion d'environnement virgule flottante qui permet une gestion améliorée des erreurs du système de calcul en nombres flottant.

VI-G-1. Dépassement de capacité de la valeur de retour▲

VI-G-2. Le contrôle des arrondis▲

int fegetround (void);

int fesetround (int mode);

VI-G-3. Les exceptions▲

int fetestexcept (int exceptions);

void feraiseexcept (int exceptions);

void feclearexcept (int exceptions);

void fegetexceptflag (fexcept_t *svg, int execptions);
void fesetexceptflag (const fexcept_t *svg, int execptions);

VI-G-4. Manipulation de l'environnement▲

void fegetenv (fenv_t *ecf);
void fesetenv (const fenv_t *ecf);

void feupdateenv (const fenv_t *ecf);

void feholdexcept (fenv_t *ecf);