Les constantes en C : const, #define et enum

Une constante est une valeur dotée d'un nom et de la promesse qu'elle ne changera pas. Le C vous offre trois mécanismes pour cela, et ce sont réellement des choses différentes sous le capot - l'une est une variable, l'autre une substitution de texte, la troisième un type entier.

Pourquoi nommer une valeur

Comparez ces deux lignes :

double area = 3.14159 * r * r;
double area = PI * r * r;

La seconde est meilleure pour trois raisons qui se manifestent toutes plus tard. Elle dit ce que le nombre signifie. Elle apparaît à un seul endroit, donc changer la précision est une modification plutôt qu'une recherche. Et une faute de frappe dans PI est une erreur de compilation, là où une faute dans 3.14195 est une mauvaise réponse.

Les nombres sans nom éparpillés dans le code s'appellent des nombres magiques, et les supprimer est l'une des améliorations les moins chères que vous puissiez apporter à un programme C.

const

Le mot-clé const marque une variable comme étant en lecture seule :

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Aire pour r=%.1f : %.4f\n", r, PI * r * r);
    printf("Capacite : %d utilisateurs\n", MAX_USERS);

    /* PI = 3.0;  <- decommentez cette ligne et le programme ne compilera pas */
    return 0;
}

Décommentez l'affectation et le compilateur refuse : assignment of read-only variable 'PI'. Cette erreur à la construction est tout l'intérêt.

Une variable const est une vraie variable. Elle a un type, donc le compilateur vérifie comment vous l'utilisez. Elle obéit à la portée, donc un const dans une fonction ne fuit pas dehors. Elle a une adresse, vous pouvez donc pointer dessus. Et un débogueur peut vous montrer son nom et sa valeur.

Un const doit être initialisé au point de déclaration - il n'y a pas de seconde chance :

const int limit;       /* erreur (ou garbage pour toujours) : rien ne pourra l'affecter plus tard */
const int limit = 50;  /* correct */

#define

L'alternative du préprocesseur est une macro :

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Bienvenue dans le systeme"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Aire pour r=%.1f : %.4f\n", r, PI * r * r);
    printf("Capacite : %d utilisateurs\n", MAX_USERS);
    return 0;
}

Ce n'est pas une variable. Avant que le compilateur ne tourne, le préprocesseur remplace chaque occurrence de PI dans le source par les caractères 3.14159265358979. Le compilateur ne voit jamais le nom - c'est exactement pourquoi un #define n'a pas de type et ne peut pas apparaître dans un débogueur.

Remarquez qu'il n'y a ni point-virgule ni =. Une macro est du texte brut, d'où cette erreur courante :

#define MAX_USERS 100;        /* notez le point-virgule */

int limit = MAX_USERS + 1;    /* se developpe en : int limit = 100; + 1;  -> erreur */

qui produit une erreur sur une ligne qui ne ressemble en rien à la définition. La convention de nommage en majuscules pour les macros existe précisément pour que les lecteurs sachent qu'une substitution a lieu.

Les macros s'écrivent conventionnellement en MAJUSCULES ; les variables const suivent généralement la même convention quand elles remplissent le même rôle.

Les constantes d'énumération

La troisième forme vous donne un ensemble d'entiers nommés :

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* une veritable constante de compilation */

    printf("le tampon contient %zu octets\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, today=%d\n", MON, TUE, WED, today);
    return 0;
}

Les valeurs commencent à 0 et augmentent de un tant que vous ne les affectez pas, donc MON vaut 0 et FRI vaut 4. Un enum { ... } anonyme est un idiome courant pour de simples constantes entières.

Les constantes d'énumération ont un vrai avantage sur les deux alternatives : ce sont des constantes entières de compilation que le compilateur comprend, et elles sont visibles du débogueur. L'histoire complète est sur les enums en C.

Laquelle utiliser

Le choix par défaut devrait être const. Prenez #define quand la valeur doit exister avant la compilation, et enum quand il vous faut un entier de compilation ou un groupe nommé.

L'endroit où cela mord vraiment, ce sont les tailles de tableaux :

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* ok */
int global_b[ENUM_SIZE];      /* ok */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* tableau de taille variable C99 - fonctionne ici... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globaux : %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

Un const int en C est une variable en lecture seule, pas une expression constante de compilation. Dans une fonction, C99 accepte int local[const_size] en en faisant un tableau de taille variable ; à portée fichier, dans une struct ou comme étiquette de case, il est rejeté net. enum et #define fonctionnent partout.

(C'est l'une des vraies différences avec le C++, où un const int est une expression constante. Le code qui circule entre les deux langages trébuche dessus.)

const avec les pointeurs

const et les pointeurs se combinent de trois façons, et les sens ne sont pas interchangeables. Lisez la déclaration depuis le nom vers l'extérieur :

const char *p;          /* p pointe vers des char qui ne doivent pas etre modifies */
char * const q;         /* q lui-meme ne peut pas etre repointe ; les char peuvent changer */
const char * const r;   /* ni le pointeur ni les char ne peuvent changer */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- erreur : les donnees sont const a travers p */
    p = "world";  /* mais repointer p est permis */
    printf("p pointe maintenant vers : %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modifier les donnees a travers q est permis */
    /* q = "world";  <- erreur : q lui-meme est const */
    printf("text vaut maintenant : %s\n", text);
    return 0;
}

La forme const char * est celle que vous écrirez le plus, car c'est le bon type pour un paramètre de fonction qui lit une chaîne sans la modifier :

#include <stdio.h>

/* Le const promet a l'appelant : cette fonction ne modifiera pas votre chaine. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("voyelles dans \"programming\" : %zu\n", count_vowels("programming"));
    return 0;
}

Ajouter const à un paramètre en lecture seule ne coûte rien et documente le contrat d'une façon que le compilateur fait respecter. Cela vaut la peine partout.

Les littéraux de chaîne sont de fait const

Un piège subtil que const existe pour attraper :

char *s = "hello";   /* C legal, mais s pointe dans de la memoire en lecture seule */
s[0] = 'H';          /* comportement indefini - generalement un plantage */

Les littéraux de chaîne vivent dans une section en lecture seule de l'exécutable. Écrire à travers ce pointeur provoque typiquement une erreur de segmentation. Déclarer le pointeur const char *s = "hello"; fait rejeter l'affectation par le compilateur au lieu de la laisser planter à l'exécution.

Si vous avez besoin d'une chaîne modifiable, copiez-la dans un tableau :

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* lecture seule, non modifiable */
    char copy[] = "hello";           /* un tableau : une copie privee, modifiable */

    copy[0] = 'H';
    printf("litteral : %s\n", literal);
    printf("copie    : %s\n", copy);
    return 0;
}