Notes sur le langage C

Seules les données statiques sont initialisées avant le lancement de main(). Les autres ont une valeur indéterminée. Il est donc nécessaire de les initialiser avant utilisation (lecture). Sauf indication explicite contraire, l'initialisation par défaut des données statiques est 0.

On appelle structure visible une structure dont les éléments sont visibles de l'utilisateur.

Une 'définition de structure' est le moyen par lequel le programmeur indique au compilateur comment est constituée une structure. Cette opération ne réserve aucune mémoire.

struct mastructure
   {
      type_1 element_a;
      type_2 element_b;
   };

Ensuite, une structure peut être instanciée, c'est-à-dire qu'une instance de cette structure est définie en mémoire.

struct mastructure mastructure;

Ces informations suffisent à définir et instancier n'importe quelle structure 'visible'.

On appelle structure opaque une structure dont les éléments ne sont pas visibles de l'utilisateur.

Pour cela, on utilise une définition réduite (ou incomplète) qui consiste à définir le nom de la structure sans en préciser le contenu.

struct mastructure;

Cette définition dite incomplète ne permet évidemment pas de créer une instanciation, puisque le compilateur ignore le contenu de la structure. Il n'a donc pas les moyens d'en déterminer la taille.

Par contre, il est possible de créer un pointeur de ce type :

struct mastructure *p;

Il devient alors possible de créer une fonction qui retourne un pointeur de ce type :

struct mastructure *fonction(void);

de passer ce pointeur en paramètre une fonction :

void fonction(struct mastructure *p);

d'en faire un élément de structure, etc.

Évidemment, il faudra que la structure soit définie 'quelque part' afin qu'elle soit instanciable et que ses éléments soient manipulables.

On va donc créer un fichier source (.c) séparé d'implémentation contenant les fonctions permettant la création (instanciation) des données, et une interface (header ou .h) ne comportant que la définition incomplète de la fonction et, au minimum, les 2 fonctions permettant la création et la suppression d'une instance de la structure.

Soit la structure 'xxx'. On obtient :

/* xxx.h Interface */
#ifndef H_XXX
#define H_XXX
 
/* définition incomplète de structure */
struct xxx;
 
/* prototypes des fonctions */
struct xxx *xxx_create (void);
void xxx_delete (struct xxx *p);
/*, etc. */
 
#endif

/* xxx.c Implémentation */
#include "xxx.h"
 
/* définition de la structure (exemple) */
struct xxx
{
   int a;
   char b[10];
};
 
/* fonctions publiques */
struct xxx *xxx_create (void)
{
   /* a completer */
}
 
void xxx_delete (struct xxx *p)
{
   /* a completer */
}

Exemple d'utilisation :

/* test.c */
#include "xxx.h"
 
#include <stddef.h>
 
int main (void)
{
   /* instanciation */
   struct xxx *p = xxx_create ();
 
   /* tout appel de fonction peut échouer... */
   if (p != NULL)
   {
      /* utilisation de l'objet xxx
         (via de nouvelles fonctions à créer)
 
         ...
       */
 
      /* fin d'utilisation : destruction de l'objet */
      xxx_delete (p), p = NULL;
   }
   return 0;
}

Je laisse au lecteur le soin de proposer une ou des implémentations de xxx_create() et de xxx_delete(), sachant qu'on n’a pas forcément besoin d'un nombre illimité d'instanciations…

Il est possible, afin de simplifier l'écriture (notamment pour les interfaces publiques), de remplacer le nom de la structure par un nom différent (alias ou pseudonyme) généralement plus court. Il est recommandé de ne pas abuser de l'abstraction, car les possibilités sont réduites en C et il est bon que le programmeur garde en tête qu'il manipule des pointeurs.

Ceci est possible :

typedef struct xxx xxx_s;

mais ceci est déconseillé :

typedef struct xxx *xxx; /* /!\ */

Détails d'application dans l'article Les types abstraits de données (ADT).

Il est recommandé d'utiliser le préfixe g_ ou G_ pour signifier qu'une variable est globale.

Il est préférable pour éviter la dispersion, d'utiliser une ou des structures de variables globales regroupées par fonction, plutôt qu'une multitude de variables.

Il est recommandé que la définition d'une variable globale soit faite exclusivement dans un fichier source (.c). Ce fichier doit inclure le fichier de déclaration (entête).

/* data.c */
 
#include "data.h"
 
int G_x;
 
/* la taille du tableau est définie
 * dans la déclaration.
 */
double G_a[];
 
data_s G_data;

Il est recommandé que la déclaration d'une variable globale soit faite exclusivement dans un fichier d'entête (.h). Ce fichier doit être inclus dans le fichier de définition et dans tous les fichiers d'utilisation (.c). Comme tous les fichiers d'entêtes, celui-ci dispose de protections contre les inclusions multiples.

#ifndef H_DATA
#define H_DATA
 
/* data.h */
 
typedef struct
{
   int a;
   char b[123];
}
data_s;
 
extern int G_x;
 
/* la dentition de la taille du tableau est unique. Elle est faite ici. */
extern double G_a[12];
 
extern data_s G_data;
 
#endif /* guard */

Il est recommandé que le fichier qui utilise une variable globale inclue le fichier de déclaration (.h).

/* appli.c */
 
#include "data.h"
 
int main (void)
{
   G_x = 123;
 
   G_data.a = 456;
 
   G_a[3] = 123.456;
 
   return 0;
}

Le mot clé 'const' est un qualificateur (qualifier) d'objet. Il lui fait perdre sa qualité par défaut qui est 'accessible en lecture ou en écriture' pour le modifier en 'accessible en lecture seule'. Par exemple :

int x = 3;
int const y = 4;
 
x = 5; /* accès en écriture possible */
y = 6; /* accès en écriture interdit */

Le compilateur signale l'erreur.

On peut placer indifféremment le qualificateur const avant ou après le type.

int const a = 7;
const int b = 8;

Mais je conseille néanmoins la première forme, car elle est beaucoup plus claire (notamment avec les pointeurs).

Il est techniquement possible de définir un objet const non initialisé :

int const c;

Évidemment, l'intérêt est limité, mais il a son application dans un contexte particulier : les paramètres de fonctions.

Le cas des pointeurs est un peu plus complexe, puis qu'il y a en quelque sorte deux objets pour le prix d'un !

• le pointeur lui-même qui peut être qualifié const ;
• l'objet pointé qui peut lui-même être qualifié const.

Pour le pointeur, celui-ci étant un objet comme autre, la même règle s'applique, sachant que const doit être placé juste avant l'identificateur, c'est-à-dire après le dernier * :

int a;
int * const pa = &a;
 
pa++; /* interdit */
*pa = 123; /* OK */

Mais un autre qualificateur const peut être utilisé pour préciser les droits du pointeur sur l'objet pointé.

Celui-ci se place à la gauche de l'*, avant ou après le typem :

int a = 123;
int const * pa = &a;
const int * pb = &a;

mais là encore, pour des questions de clarté du code, je recommande la première forme. Ce qualificateur interdit la modification de l'objet via le pointeur (mais s'il n'est pas lui-même qualifié const, l'objet reste modifiable directement, évidemment).

int a = 123;
int const * pa = &a;
 
*pa = 456; /* interdit */
a = 456; /* OK */

int const a = 123;
int * pa = &a;
 
*pa = 456; /* comportement indéfini */

Cependant, le plus souvent, le compilateur signale un problème au moment de l'affectation du pointeur.

int * pa = &a;

mais il convient de rester extrêmement prudent. Le C est un langage qui demande rigueur et maîtrise.

int const a = 123;
int * pa = (int *) &a; /* NE PAS FAIRE CECI */

Le rôle du qualificateur const est particulièrement utile avec les pointeurs, notamment sur des chaines de caractères, qui, rappelons-le, ne sont pas modifiables. Il est fortement recommandé de définir tout pointeur sur une chaine de caractères avec le qualificateur const :

char const *p = "hello";

Il est utile aussi pour les pointeurs passés en paramètre à des fonctions. Il permet en effet de restreindre l'accès à la variable pointée à un mode 'lecture seule', ce qui évite bien des erreurs de codage. (La modification d'une variable étant une opération lourde de conséquences si elle est faite au mauvais moment).

Une fonction qui affiche le contenu d'un tableau ou d'une structure, par exemple, n'a pas à la modifier. On fixe donc les règles du jeu dès la définition du prototype :

void display (T const *p)

Une utilisation astucieuse et intelligente du qualificateur const permet d'écrire du code plus sûr.