Fonctions et structure des programmes en C

Une fonction regroupe une tâche pour qu’une autre partie du programme puisse l’appeler. Donne-lui un nom qui décrit cette tâche et choisis ses données d’entrée et son résultat avant d’écrire son corps. Dans un programme C ordinaire exécuté dans un environnement hôte, l’exécution commence dans main.

Construire une définition

int square(int n)
{
    return n * n;
}

La définition comporte un type de retour (int), un nom (square), une liste de paramètres (int n) et un corps entre accolades. Le paramètre est la variable locale qui reçoit une donnée d’entrée. Un argument est la valeur fournie par un appel : dans square(6), cette valeur est 6. L’appel produit 36. Définis chaque fonction au niveau du fichier, en dehors des autres fonctions ; le C standard n’autorise pas les définitions de fonctions imbriquées.

Chaque paramètre doit avoir son propre type. Écris int max(int a, int b), avec une virgule entre les déclarations. Dans un appel, fournis les valeurs sans leurs types : max(8, 3).

Renvoyer une valeur à la fonction appelante

int max(int a, int b)
{
    if (a > b)
        return a;
    return b;
}

Un return termine immédiatement l’appel en cours. Pour max(8, 3), le premier retour est exécuté, donc le second n’est jamais atteint. Une expression renvoyée est convertie dans le type de retour de la fonction. Choisis ce type de façon à préserver le type de résultat dont tu as besoin.

Pour un résultat fractionnaire, utilise des calculs à virgule flottante du début à la fin :

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

L’appel c_to_f(37.0) renvoie 98.6. Une version entière utilisant c * 9 / 5 + 32 renvoie 98, car la division supprime la partie fractionnaire. Réorganiser le calcul en 9 / 5 * c + 32 fait d’abord évaluer 9 / 5 à 1, ce qui donne 69 pour 37. Un type de retour à virgule flottante ne peut pas, à lui seul, annuler un calcul entier déjà effectué dans le corps.

Utiliser le résultat

Un appel qui renvoie une valeur est une expression. Avec la définition ci-dessus, square(3) + square(4) donne 25. Dans square(square(2)), l’appel intérieur renvoie 4, qui devient l’argument de l’appel extérieur, ce qui donne 16. Une instruction telle que square(5); est autorisée, mais ignore la valeur renvoyée.

Afficher et renvoyer sont deux opérations différentes. printf affiche du texte ; return fournit un résultat que la fonction appelante peut stocker ou utiliser dans une autre expression. Si une fonction ordinaire dont le type de retour n’est pas void atteint son accolade fermante sans rien renvoyer et que la fonction appelante utilise son résultat, le comportement est indéfini. Compile avec -Wall -Wextra pour faciliter la détection des retours manquants.

Fonctions qui ne produisent pas de valeur

Une fonction void accomplit une tâche sans renvoyer de valeur. Elle peut quitter avant la fin avec return;. Par exemple, void print_line(int width) peut afficher une ligne de tirets, mais int x = print_line(5); est invalide car l’appel ne fournit aucune valeur. Pour une fonction sans donnée d’entrée, écris void dans la liste des paramètres, comme dans int read_sensor(void).

int main(void) renvoie un code de retour à l’environnement hôte. Utilise return 0; pour indiquer la réussite ; <stdlib.h> fournit aussi EXIT_SUCCESS et EXIT_FAILURE. Atteindre la fin de main renvoie automatiquement zéro. Les autres fonctions qui renvoient une valeur ne bénéficient pas de cette exception.

Un appel de fonction nécessite une déclaration que le compilateur a déjà rencontrée. Si la définition vient plus loin, place un prototype avant le premier appel. Le prototype indique au compilateur comment vérifier l’appel sans fournir le corps de la fonction.

Séparer la promesse du corps

#include <stdio.h>

double c_to_f(double c);

int main(void)
{
    printf("%.1f\n", c_to_f(25.0));
    return 0;
}

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

Le prototype se termine par un point-virgule. La définition possède un corps et aucun point-virgule entre sa liste de paramètres et son accolade ouvrante. Une organisation pratique est la suivante : fichiers d’en-tête, prototypes, main, puis les autres définitions. Le résultat affiché ici est 77.0.

Les noms des paramètres sont facultatifs dans les prototypes : double c_to_f(double); déclare la même fonction. Des noms comme c peuvent documenter une donnée d’entrée, mais ils ne doivent pas nécessairement correspondre aux noms de la définition. Toutes les déclarations doivent concorder sur le type de retour et les types des paramètres. Une fonction utilisée doit avoir une définition ; répéter des prototypes compatibles ne crée pas de fonctions supplémentaires.

Ce que vérifie le compilateur

Avec un prototype, le compilateur vérifie le nombre d’arguments et convertit chaque valeur fournie dans le type déclaré du paramètre. Avec double c_to_f(double c);, c_to_f() et c_to_f(20.0, 5.0) ont tous deux un nombre incorrect d’arguments et nécessitent un diagnostic.

Une différence de type numérique peut en revanche donner lieu à une conversion autorisée :

int half(int n)
{
    return n / 2;
}

Pour half(7.9), la conversion donne d’abord au paramètre la valeur 7. La division entière produit ensuite 3. Pour half(-7.9), la conversion donne -7, et la division produit -3. Dans les deux cas, les parties fractionnaires sont supprimées par troncature vers zéro. L’appel ne conserve pas la valeur double d’origine simplement parce que l’argument a été écrit avec un point décimal. Ajoute -Wconversion si tu souhaites recevoir des avertissements sur ces conversions.

Indiquer explicitement l’absence de paramètres

En C17, une liste de paramètres vide dans une déclaration empêche la vérification complète des arguments ; elle n’autorise pas pour autant des arguments arbitraires pour la fonction finalement définie. Utilise systématiquement (void). GCC 15 a changé son dialecte C par défaut pour gnu23 ; -std=c17 rend donc explicite la norme visée lorsque tu suis ces exemples.

Corriger un problème de déclaration

Appeler une fonction non déclarée enfreint les règles du C moderne. Inclus le fichier d’en-tête standard qui la déclare, comme <stdio.h> pour printf, ou ajoute ton propre prototype correspondant. Les versions actuelles de GCC et de Clang rejettent normalement les déclarations implicites.

Un prototype tel que double area(double r); ne peut pas correspondre à une définition qui renvoie un float et reçoit un float. Inclus le fichier d’en-tête d’un module dans le fichier qui définit ses fonctions pour que le compilateur puisse les comparer. N’essaie pas de corriger une incompatibilité de types en ajoutant une conversion explicite à l’appel : corrige la déclaration et la définition pour qu’elles décrivent la même fonction.

C passe chaque argument par valeur : chaque paramètre reçoit initialement une copie de la valeur de son argument. Affecter une valeur à un paramètre entier ordinaire modifie cette copie, même s’il porte le même nom qu’une variable de la fonction appelante.

Suivre la copie

Après avoir inclus <stdio.h> et placé cette définition avant son appel :

void double_it(int n)
{
    n *= 2;
    printf("inside: %d\n", n);
}

La fonction appelante exécute :

int score = 21;
double_it(score);
printf("after: %d\n", score);

Le résultat affiché est inside: 42, puis after: 21. Le paramètre passe de 21 à 42 ; aucune instruction n’affecte de valeur au score de la fonction appelante.

Conserver un résultat renvoyé

int doubled(int n)
{
    return n * 2;
}

La fonction calcule une valeur ; l’affectation dans la fonction appelante met à jour sa variable. Renvoyer la valeur d’une variable locale est sûr : int total = a + b; return total; copie la valeur avant que la variable locale automatique cesse d’exister. Les calculs qui utilisent uniquement des paramètres et des résultats renvoyés peuvent être testés sans préparer d’état partagé caché.

Comprendre pourquoi un échange de valeurs échoue

void swap(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

Après int p = 3, q = 7; swap(p, q);, la fonction appelante a toujours p == 3 et q == 7. Le corps a échangé ses copies. Modifier les objets de la fonction appelante par des paramètres nécessite leurs adresses, transmises sous forme de valeurs de pointeurs.

Séquencer les arguments lorsque l’ordre compte

Les arguments peuvent être des expressions comme a + 1 ou square(b). Leur évaluation s’achève avant le début du corps de la fonction appelée, mais leur ordre d’évaluation n’est pas spécifié. Deux appels à next_ticket(), qui modifie un état, dans un même affichage peuvent fournir les numéros dans un ordre ou dans l’autre. Utilise des instructions distinctes :

int first = next_ticket();
int second = next_ticket();
printf("%d %d\n", first, second);

Évite f(i, i++) : la lecture et la modification non séquencées de i produisent un comportement indéfini.

Un appel suspend la fonction appelante jusqu’à ce qu’un résultat soit prêt. Suivre les appels actifs explique comment un programme revient au bon endroit et pourquoi la récursivité nécessite une règle d’arrêt.

Conserver un enregistrement par appel actif

La plupart des implémentations utilisent une pile d’appels. Chaque appel actif possède un cadre qui enregistre les valeurs de ses paramètres, ses variables locales automatiques et l’endroit où reprendre dans la fonction appelante. La norme spécifie le comportement sans imposer cette organisation particulière de la mémoire.

Si main appelle print_table et que print_table appelle c_to_f, la fonction de conversion revient en premier. L’exécution reprend dans print_table, qui revient ensuite à main. Les variables locales automatiques ordinaires appartiennent à un seul appel. Une variable locale statique est différente : tous les appels partagent son unique valeur stockée.

Suivre la descente d’un calcul récursif

Une fonction récursive s’appelle elle-même sur un problème plus petit. Un cas de base renvoie directement un résultat ; un cas récursif progresse vers ce cas de base.

int factorial(int n)
{
    if (n <= 1)
        return 1;
    return n * factorial(n - 1);
}

Pour factorial(4), le premier appel ne peut pas terminer sa multiplication avant le retour de factorial(3). Cet appel attend factorial(2), qui attend factorial(1).

Il y a quatre appels actifs de la fonction factorielle au point le plus profond. Chacun possède son propre n ; atteindre n == 1 ne modifie pas les valeurs des appels précédents.

Suivre la remontée des résultats

L’appel du cas de base renvoie 1. L’appel avec n == 2 calcule alors 2 * 1 et renvoie 2. Le suivant renvoie 3 * 2, soit 6 ; le premier renvoie 4 * 6, soit 24. Inscris les valeurs de retour dans le suivi à la remontée, une fois le résultat de la fonction appelée connu.

La condition d’arrêt doit être atteignable pour les valeurs d’entrée prises en charge. Si le test était n == 1, commencer à zéro continuerait à lancer des appels avec -1, -2 et des valeurs inférieures au lieu d’atteindre un. La poursuite de la récursivité épuise les ressources et peut provoquer un plantage. Le test plus large n <= 1 arrête ces appels, même si la factorielle mathématique est utilisée pour les entiers positifs ou nuls.

Vérifier la profondeur et le type du résultat

S’arrêter correctement ne garantit pas que le résultat est représentable. Sur une plateforme où int est sur 32 bits, la plus grande valeur est 2147483647. factorial(12) donne 479001600, qui est représentable ; factorial(13) nécessiterait 6227020800, qui ne l’est pas. Un débordement d’entier signé constitue un comportement indéfini.

Une boucle peut calculer la factorielle en conservant un produit courant dans un seul appel de fonction. La récursivité est utile lorsque le problème suivant a la même structure mais une taille plus petite. Pour les entiers positifs, la somme des chiffres est un autre exemple : sum_digits(472) nécessite 2 + sum_digits(47), puis 2 + 7 + sum_digits(4), ce qui donne 13. Un suivi doit montrer à la fois la réduction de la valeur d’entrée et la combinaison ultérieure des valeurs renvoyées.

La portée est la partie du code source où un nom peut être utilisé. Lis les accolades et les déclarations pour déterminer quelle variable une expression désigne ; l’ordre des appels ne modifie pas ces règles.

Trouver la limite de la portée

Une variable déclarée dans un bloc a une portée de bloc, qui commence juste après son déclarateur et se termine à l’accolade fermante de ce bloc. Les paramètres sont visibles dans le corps de leur fonction. Une déclaration dans l’en-tête d’un for, telle que for (int i = 0; i < 10; i++), rend i disponible dans cette boucle, mais pas après celle-ci.

Un nom déclaré en dehors de toutes les fonctions a une portée de fichier, de sa déclaration jusqu’à la fin de l’unité de traduction. Les fonctions situées au-dessus de cette déclaration ont besoin d’une déclaration antérieure pour l’utiliser. Un nom de paramètre dans un prototype a une portée de prototype, qui se termine avec le prototype. Ainsi, double c_to_f(double c); peut être suivi d’une définition qui nomme le paramètre degrees.

Suivre le masquage de l’intérieur vers l’extérieur

#include <stdio.h>

int x = 10;

void show(void)
{
    printf("%d\n", x);
}

int main(void)
{
    int x = 5;
    {
        int x = 1;
        printf("%d\n", x);
    }
    printf("%d\n", x);
    show();
    return 0;
}

Le premier affichage, dans le bloc intérieur, utilise 1, le suivant utilise 5 et show affiche 10. La déclaration visible de x la plus proche l’emporte. Quitter le bloc intérieur rend à nouveau visible la variable locale extérieure. Appeler show ne rend pas la variable locale de main visible dans cette fonction : show a été définie là où le x de portée de fichier est visible.

Différentes fonctions peuvent chacune déclarer un i, un count ou un result local. Ce sont des variables distinctes car leurs déclarations appartiennent à des blocs différents.

Déclarer une valeur là où ses utilisations ultérieures peuvent y accéder

Ce code ne compile pas :

if (temp > 30.0) {
    int warning = 1;
}
printf("%d", warning);

L’affichage se trouve en dehors de la portée de warning. Si la valeur doit être utilisée ensuite, déclare-la et initialise-la avant la condition :

int warning = 0;
if (temp > 30.0) {
    warning = 1;
}
printf("%d", warning);

L’initialisation fournit aussi la valeur pour le chemin où la condition est fausse.

Éviter de créer accidentellement une variable

Déclarer int total = 0; dans une boucle crée une nouvelle variable locale à chaque entrée dans son bloc. Si tu voulais accumuler des valeurs dans un total extérieur, utilise une affectation comme total += value;. Active -Wshadow pour faciliter la détection des noms masqués.

La portée commence avant l’évaluation de l’initialiseur. Dans un bloc, int x = x + 1; lit le nouveau x, non initialisé, même s’il existe un x extérieur. Utilise un autre nom si l’initialiseur a besoin de la valeur extérieure.

La portée décrit où un nom est visible dans le code source. La durée de stockage décrit combien de temps son objet existe pendant l’exécution du programme. Une variable locale statique a une portée de bloc, tandis que sa valeur stockée existe pendant toute l’exécution.

La durée de stockage décrit combien de temps l’espace de stockage d’une variable existe. Utilise des variables automatiques pour le travail propre à un appel et le stockage statique lorsqu’une valeur doit subsister entre les appels.

Comparer une nouvelle valeur à une valeur mémorisée

Les paramètres et les variables ordinaires de portée de bloc ont une durée de stockage automatique. Chaque appel de fonction reçoit ses propres instances. Une déclaration sans initialiseur, telle que int sum;, ne fournit aucune valeur initiale utilisable. Initialise un accumulateur avant de le lire : int sum = 0;.

Les variables de portée de fichier et les variables de portée de bloc déclarées static ont une durée de stockage statique. Elles existent pendant toute l’exécution du programme. L’initialisation a lieu une fois avant le démarrage du programme ; sans initialiseur explicite, les objets numériques valent initialement zéro.

int next_ticket(void)
{
    static int n = 0;
    n++;
    return n;
}

Trois appels dans des instructions distinctes renvoient 1, 2 et 3. L’initialiseur ne s’exécute pas à nouveau à l’entrée dans la fonction. Supprimer static crée un nouveau n = 0 automatique à chaque appel : les trois appels renvoient donc tous 1.

Le nom n conserve une portée de bloc. Les autres fonctions ne peuvent pas le nommer directement. Les appels récursifs partagent eux aussi la même variable locale statique ; ils ne reçoivent pas de copies statiques distinctes comme c’est le cas pour les variables locales automatiques.

Initialiser une fois, affecter une valeur si nécessaire

En C, un initialiseur numérique statique doit être une expression constante. static int limit = 12; est valide ; static int limit = read_sensor(); est invalide. Effectue une affectation à l’exécution dans le code exécutable lorsqu’une valeur doit provenir d’un appel. Une instruction telle que n = 0; s’exécute chaque fois que l’exécution l’atteint : la placer au début de next_ticket remettrait donc le compteur à zéro à chaque appel.

Lire les spécificateurs de classe de stockage

Les compilateurs modernes choisissent eux-mêmes l’attribution des registres : écrire register améliore donc rarement le code. En C17, auto int x; signifie la même chose qu’une variable locale ordinaire int x;. C23 autorise aussi l’inférence de type avec auto x = 3.5;, qui déclare un double.

C17 possède aussi _Thread_local, écrit thread_local en C23, pour le stockage propre à un thread. La grammaire regroupe typedef avec les spécificateurs de classe de stockage, bien qu’il nomme un type au lieu de choisir un stockage. En C17, un seul spécificateur de classe de stockage apparaît normalement dans une déclaration ; _Thread_local peut aussi accompagner static ou extern.

Un extern int count; de portée de bloc ne crée pas de copie locale automatique. Il déclare un objet doté d’une liaison et d’une durée de stockage statique. Tiens toujours compte de l’emplacement de la déclaration avant de déterminer l’effet d’un mot-clé de classe de stockage.

Une variable globale est déclarée à la portée de fichier, en dehors de toute fonction. Elle conserve une valeur pendant toute l’exécution et peut donner à plusieurs fonctions accès à un état partagé.

Suivre l’objet partagé

#include <stdio.h>

double total_km = 0.0;

void add_trip(double km)
{
    total_km += km;
}

int main(void)
{
    add_trip(12.5);
    add_trip(7.25);
    printf("%.2f\n", total_km);
    return 0;
}

Les deux appels mettent à jour le même objet et produisent 19.75. Le paramètre km reste une copie ; la fonction effectue séparément une affectation à une variable globale qu’elle peut désigner. Le passage par valeur n’empêche pas cette affectation.

Les variables globales ont une durée de stockage statique. Les variables globales numériques valent zéro par défaut et leurs initialiseurs doivent être des expressions constantes : int error_count; vaut initialement 0, et double limit = 2.5 * 4; vaut initialement 10.0.

Vérifier la visibilité et le masquage

Un nom global n’est visible que sous sa déclaration. Une fonction située au-dessus de la définition a besoin d’une déclaration antérieure, telle que extern double total_km;.

Si add_trip contient plutôt :

double total_km = 0.0;
total_km += km;

elle crée et met à jour un objet local. La variable globale reste inchangée. Supprime la déclaration supplémentaire pour mettre à jour le total partagé ; -Wshadow aide à repérer les masquages accidentels.

Rendre les entrées explicites lorsque le partage est inutile

Un compteur d’erreurs partagé peut être utile lorsque plusieurs fonctions signalent des échecs. Mais un calcul qui lit une variable globale reçoit une donnée d’entrée absente de sa liste de paramètres. Les tests doivent préparer cet état et, pour retrouver l’origine d’une valeur incorrecte, il faut repérer les endroits susceptibles de la modifier.

Une autre solution pour le calcul des trajets est :

double with_trip(double total, double km)
{
    return total + km;
}

La fonction appelante utilise total = with_trip(total, 12.5);. Un test fournit directement les deux valeurs d’entrée, sans préparer de variable globale.

Limiter les noms partagés

Les variables ordinaires de portée de fichier ont une liaison externe. Partage une variable au moyen de déclarations et d’une seule définition ; des définitions répétées dans plusieurs fichiers rendent cette organisation invalide. À la portée de fichier, static donne au contraire une liaison interne, ce qui permet à un autre fichier de posséder son propre objet indépendant portant le même nom. Les deux objets existent toujours pendant toute l’exécution : ici, le mot-clé limite la liaison et non la durée de vie.

Le préprocesseur transforme le texte source avant que le compilateur vérifie les expressions et les types C. Ses directives commencent par #. Examine sa sortie avec gcc -E file.c lorsqu’une inclusion ou le développement d’une macro est difficile à expliquer.

Inclure des déclarations et nommer des constantes

#include <stdio.h> insère un fichier d’en-tête standard. Utilise #include "convert.h" pour un fichier d’en-tête du projet : GCC cherche d’abord dans le répertoire du fichier qui l’inclut, puis dans les chemins de recherche configurés pour les fichiers d’en-tête. L’option -Iinclude ajoute un répertoire de recherche. L’inclusion copie le texte du fichier d’en-tête ; elle n’effectue pas l’édition de liens des fonctions compilées.

Une macro objet substitue des lexèmes :

#define MAX_STUDENTS 30

Les utilisations ultérieures du lexème MAX_STUDENTS deviennent 30. Le préprocesseur ne modifie ni la chaîne "MAX_STUDENTS" ni le nom distinct MAX_STUDENTS_2. N’écris ni = ni point-virgule final. Avec #define PI 3.14159;, le développement de return PI * r * r; donne le code incorrect return 3.14159; * r * r;. Une directive se termine normalement au changement de ligne ; une barre oblique inverse finale la prolonge.

Développer avant de calculer

Une macro fonction ne comporte pas d’espace entre son nom et la parenthèse ouvrante :

#define SQUARE_BAD(x) x * x
#define SQUARE(x) ((x) * (x))

SQUARE_BAD(2 + 3) devient 2 + 3 * 2 + 3, ce qui donne 11. 100 / SQUARE_BAD(5) devient 100 / 5 * 5, ce qui donne 100. La macro avec parenthèses donne respectivement 25 et 4. Place des parenthèses autour de chaque paramètre et de toute l’expression de remplacement afin que les opérateurs environnants ne puissent pas modifier son regroupement.

Écrire à la place #define SQUARE (x) ((x) * (x)) crée une macro objet dont le remplacement commence par (x). L’espace change le sens de la définition.

Les parenthèses n’empêchent pas les évaluations répétées

SQUARE(i++) se développe en ((i++) * (i++)). Cette expression modifie i deux fois sans séquencement : le comportement est donc indéfini. Une véritable fonction telle que square(i++) évalue l’argument une seule fois avant d’entrer dans le corps. Privilégie les fonctions pour les calculs, en particulier lorsqu’une expression d’entrée modifie un état.

Une macro fonction n’a pas de types déclarés pour ses paramètres ou son retour. Les types du code C issu de son développement sont tout de même vérifiés, mais elle n’a pas de prototype précisant les conversions d’arguments. Les macros restent utiles pour les gardes d’inclusion, la compilation conditionnelle et les expressions constantes entières. En C17, une variable const int n’est pas une expression constante entière ; une macro ou une constante enum peut fournir une valeur pour case. C23 introduit aussi constexpr.

Transformer des arguments en lexèmes ou en texte

#define SHOW(expr) printf(#expr " = %d\n", expr)
#define CAT(a, b) a##b

SHOW(3 + 4); utilise # pour transformer l’argument en texte et affiche 3 + 4 = 7. CAT(temp, 1) utilise ## pour réunir les lexèmes dans le nom temp1. La conversion en chaîne de caractères utilise les lexèmes de l’argument fourni sans développer les macros dans cette occurrence ; une occurrence ordinaire de l’argument est développée.

Les macros ne suivent pas la portée de bloc. Une définition reste active jusqu’à #undef NAME ou jusqu’à la fin de l’unité de traduction, même si la directive a été écrite entre accolades. Supprime une ancienne définition avec #undef avant de lui donner un texte de remplacement différent.

La compilation conditionnelle sélectionne les lignes source qui parviennent au compilateur. Elle peut activer un affichage de débogage, choisir du code propre à une plateforme ou protéger un fichier d’en-tête contre les inclusions répétées.

Tester l’existence ou tester une valeur

#define DEBUG 0

#ifdef DEBUG
/* Kept: DEBUG exists. */
#endif

#if DEBUG
/* Removed: DEBUG expands to zero. */
#endif

#ifdef DEBUG vérifie si la macro est définie. #if DEBUG évalue sa valeur de remplacement comme une expression constante entière. Dans #if, un identificateur non défini compte pour zéro ; une macro mal orthographiée peut supprimer silencieusement une branche. Les expressions defined DEBUG et defined(DEBUG) testent toutes deux l’existence.

Utilise #ifndef NAME pour le test d’existence inverse. Ferme chaque condition avec #endif. #elif ajoute une autre condition et #else fournit le cas restant. C23 ajoute #elifdef et #elifndef ; C17 peut exprimer ces tests avec #elif defined(NAME) ou #elif !defined(NAME).

Choisir le réglage à la compilation

#ifdef DEBUG
printf("debug: c = %.1f\n", c);
#endif

gcc -std=c17 -DDEBUG main.c définit DEBUG comme 1 et conserve l’affichage. Sans cette définition, la ligne est supprimée avant la compilation. -DLEVEL=2 fournit une valeur comme si #define LEVEL 2 apparaissait avant le texte du fichier.

Cela diffère d’un if ordinaire, dont la condition est évaluée pendant l’exécution du programme. Les conditions du préprocesseur ne peuvent pas lire une variable ordinaire à l’exécution. #if 0 supprime un bloc, y compris du code contenant déjà des commentaires /* */ qui rendraient risqué son encadrement par un autre commentaire de ce type.

Protéger un fichier d’en-tête

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

La première inclusion définit CONVERT_H et conserve le prototype. Les inclusions ultérieures dans cette même unité de traduction ignorent le contenu. Utilise un nom de garde distinct fondé sur le nom du fichier d’en-tête ; évite les traits de soulignement initiaux réservés à l’implémentation. Une autre unité de traduction commence son propre prétraitement et inclut les déclarations pour elle-même. Une garde n’empêche pas différents fichiers objets de définir le même symbole externe.

De nombreux compilateurs prennent en charge #pragma once, mais ce n’est pas une directive ISO C. Les gardes fonctionnent avec les directives conditionnelles standard.

Lire les informations prédéfinies

Les valeurs de version comprennent 199901L pour C99, 201112L pour C11, 201710L pour C17 et 202311L pour C23. __func__ contient le nom de la fonction courante, mais c’est un identificateur prédéfini et non une macro.

Une branche propre à une plateforme peut tester defined(_WIN32) ou defined(__linux__), puis utiliser #else pour le cas restant. Pour rejeter explicitement une compilation non prise en charge, écris une condition suivie de #error "This program needs C11 or later" et de #endif. L’omission d’un #endif produit une erreur de directive telle que « unterminated conditional directive ».

La compilation séparée transforme chaque fichier source en fichier objet avant l’édition de liens du programme. Elle permet de réutiliser les fichiers objets inchangés et donne aux fonctions liées un emplacement clairement défini.

Suivre les étapes de compilation

Une unité de traduction est un fichier .c après prétraitement, comprenant le contenu des fichiers d’en-tête qu’il inclut. Chaque unité est compilée indépendamment.

Un fichier objet contient du code machine et des informations sur les symboles correspondant aux noms qu’il définit ou dont il a besoin. Sur les systèmes de type Unix, il porte généralement le suffixe .o. L’éditeur de liens relie les utilisations de noms externes aux définitions fournies par les fichiers objets et les bibliothèques.

Compiler deux fichiers et effectuer leur édition de liens

Supposons que convert.h déclare double c_to_f(double c);, que convert.c inclue ce fichier d’en-tête et définisse la fonction, et que main.c inclue le fichier d’en-tête et appelle la fonction.

gcc -Wall -Wextra -std=c17 -c main.c
gcc -Wall -Wextra -std=c17 -c convert.c
gcc main.o convert.o -o temp

La première commande produit main.o sans effectuer l’édition de liens. La deuxième produit convert.o. La dernière crée l’exécutable temp à partir des deux fichiers objets. Tu peux aussi compiler et effectuer l’édition de liens en une seule commande :

gcc -Wall -Wextra -std=c17 main.c convert.c -o temp

Fournis les fichiers source pour la compilation et les fichiers objets pour l’édition de liens. Les fichiers d’en-tête sont ajoutés par #include ; ne les indique pas comme des sources de programme à compiler séparément. Si seul convert.c change, réutilise main.o, reconstruis convert.o et refais l’édition de liens. Si un fichier d’en-tête partagé change, reconstruis chaque fichier objet dont le fichier source l’inclut.

Diagnostiquer l’étape qui a échoué

Une erreur de compilation concerne une unité de traduction : syntaxe invalide, nombre d’arguments incorrect ou types visibles incompatibles. L’éditeur de liens ne peut pas les corriger.

Une erreur d’édition de liens concerne le programme assemblé. Si tu compiles seulement main.c, le prototype peut permettre à la compilation de réussir alors que l’édition de liens signale « undefined reference to c_to_f » ou « Undefined symbols ». La déclaration promet une fonction ; elle ne fournit pas son code machine. Ajoute convert.c à une compilation combinée, ou convert.o à l’édition de liens.

Deux définitions externes liées d’une même fonction provoquent une erreur de symbole multiple. Un programme ordinaire possède une seule fonction main ; l’édition de liens de deux sources qui la définissent toutes deux échoue. Des fonctions static privées à leur fichier peuvent porter le même nom dans différentes unités de traduction car elles ont une liaison interne.

Les bibliothèques fournissent aussi des définitions. Sur de nombreux systèmes Linux, le code utilisant des fonctions déclarées par <math.h> nécessite une option d’édition de liens pour la bibliothèque mathématique : gcc main.c -o app -lm. Place cette option de bibliothèque après le code qui en a besoin.

Inclure l’interface, compiler l’implémentation

Évite #include "convert.c". Cela copie les corps des fonctions dans une autre unité de traduction. Si convert.c est aussi compilé et lié, ses définitions externes apparaissent deux fois. Le fichier .h d’un module partage ses déclarations ; son fichier .c est compilé une seule fois comme fichier source.

Le fichier d’en-tête d’un module partage son interface ; son fichier source fournit l’implémentation. Les fichiers appelants et le fichier d’implémentation incluent tous le fichier d’en-tête pour que leurs déclarations concordent.

Déclarer l’interface une seule fois

Un fichier convert.h muni d’une garde contient :

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);
double f_to_c(double f);

#endif

L’implémentation dans convert.c l’inclut avant les corps des fonctions :

#include "convert.h"

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

double f_to_c(double f)
{
    return (f - 32.0) * 5.0 / 9.0;
}

Un fichier appelant inclut le même fichier d’en-tête et <stdio.h>. L’appel printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); affiche 77.0 100.0.

Si l’implémentation définit float c_to_f(float c), l’inclusion de son fichier d’en-tête révèle les types incompatibles au compilateur. Une compilation indépendante sans cette déclaration peut ne pas détecter la différence.

Choisir le bon contenu

Un fichier d’en-tête contenant int count = 0; définit un objet dans chaque unité de traduction qui l’inclut, ce qui provoque des définitions externes multiples. Même int count; est une définition provisoire. Depuis la version 10, le comportement par défaut de GCC signale les copies répétées lors de l’édition de liens, tandis que certaines chaînes de compilation fusionnent les symboles communs et masquent le bogue. Utilise extern int count; dans le fichier d’en-tête et une seule définition dans un fichier source.

Rendre l’inclusion fiable

Une garde empêche le traitement répété dans une unité de traduction, y compris lors d’une inclusion indirecte par d’autres fichiers d’en-tête. Les prototypes compatibles peuvent être répétés, mais des définitions de types tels qu’un enum peuvent provoquer des erreurs de redéfinition.

Un fichier d’en-tête autonome inclut ce dont ses déclarations ont besoin. Si un prototype utilise size_t, inclus-y <stddef.h>. Les fichiers appelants ne devraient pas avoir besoin d’un ordre d’inclusion particulier.

Pour les fichiers d’en-tête du projet, les guillemets font chercher GCC d’abord dans le répertoire du fichier qui inclut. Ajoute un répertoire distinct de fichiers d’en-tête avec -Iinclude, comme dans gcc -Iinclude -std=c17 -c src/main.c. Le fichier objet de l’implémentation doit toujours être lié.

La liaison détermine si des déclarations situées à différents endroits désignent la même entité. Elle est distincte de la portée, qui décrit où un nom peut être utilisé, et de la durée de stockage, qui décrit combien de temps un objet existe.

Relier un nom à un objet

Les fonctions et les variables ordinaires de portée de fichier ont une liaison externe par défaut. À la portée de fichier, static donne une liaison interne. Les variables locales automatiques ordinaires et les paramètres n’ont pas de liaison.

Pour partager un compteur d’erreurs, place ces déclarations dans un fichier d’en-tête muni d’une garde :

extern int error_count;
void log_error(int code);

Un fichier source inclut ce fichier d’en-tête et fournit :

int error_count = 0;

void log_error(int code)
{
    printf("error: %d\n", code);
    error_count++;
}

Ce fichier source inclut aussi <stdio.h> pour printf. Les autres fichiers source incluent le fichier d’en-tête partagé, sans ajouter de seconde définition. Après trois appels, chaque fonction appelante qui lit error_count désigne le même objet et voit 3.

Distinguer déclaration et définition

extern int error_count; déclare un objet existant et n’alloue aucun nouvel espace de stockage. int error_count = 0; le définit. Un initialiseur change la situation : à la portée de fichier, extern int error_count = 0; est une définition malgré le mot-clé. Garde l’initialiseur dans l’unique fichier qui définit la variable.

Dans les déclarations ordinaires de fonctions publiques, extern est facultatif : double c_to_f(double c); déclare déjà une fonction à liaison externe. Inclus la déclaration publique dans le fichier qui contient sa définition pour que le compilateur puisse vérifier leur compatibilité.

Masquer l’état derrière des fonctions

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

La valeur stockée existe pendant toute l’exécution, mais seule cette unité de traduction peut y faire référence par le nom count. Place les prototypes des fonctions publiques dans un fichier d’en-tête. Un autre fichier peut incrémenter et lire le compteur par ces fonctions sans modifier directement la variable privée. Une fonction auxiliaire peut aussi être static lorsque les autres fichiers n’en ont pas besoin.

Diagnostiquer un mauvais choix de liaison

Une définition static int count; dans un fichier d’en-tête crée un compteur privé indépendant dans chaque unité de traduction qui l’inclut. Mettre l’un à jour ne met pas les autres à jour. Les gardes d’inclusion ne fusionnent pas ces objets : chaque unité de traduction prétraite sa propre copie du fichier d’en-tête.

Une fonction définie static dans une unité de traduction ne peut pas répondre à un appel externe provenant d’une autre ; l’édition de liens échoue pour ce nom externe. Ne donne une liaison externe qu’aux fonctions dont les autres fichiers ont besoin et déclare-les dans le fichier d’en-tête.

Dans une fonction, static donne à une variable locale un stockage conservé sans élargir sa portée. En dehors des fonctions, il donne à un objet ou une fonction une liaison interne. Les variables de portée de fichier ont une durée de stockage statique avec ou sans ce mot-clé.

make lit Makefile ou makefile dans le répertoire du projet et met à jour la cible demandée. Sans argument indiquant une cible, il construit normalement la première cible ordinaire.

Enregistrer les sorties et les entrées

Une règle commence par target: prerequisites. Sa recette se trouve soit sur les lignes suivantes indentées par une tabulation, soit après un point-virgule sur la même ligne :

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g

temp: main.o convert.o; $(CC) $(CFLAGS) -o temp main.o convert.o

main.o: main.c convert.h; $(CC) $(CFLAGS) -c main.c

convert.o: convert.c convert.h; $(CC) $(CFLAGS) -c convert.c

.PHONY: clean
clean:; rm -f temp main.o convert.o

Ici, temp est la cible par défaut. make clean demande l’action de nettoyage. Si tu écris une recette sur la ligne suivante, utilise une véritable tabulation : des espaces peuvent provoquer « missing separator ». L’option d’un éditeur qui rend les caractères blancs visibles aide à repérer la différence.

Suivre les décisions de reconstruction

Make met d’abord à jour les dépendances d’une cible. Il reconstruit ensuite la cible si elle est absente ou si une dépendance a une date de modification plus récente.

• Première compilation : compiler les deux sources, puis effectuer l’édition de liens de temp : trois commandes.
• Aucun changement : aucune recette du programme n’a besoin d’être exécutée.
• Modification de convert.c uniquement : le recompiler et refaire l’édition de liens : deux commandes ; réutiliser main.o.
• Modification de convert.h : recompiler les deux sources et refaire l’édition de liens : trois commandes.

Le fichier d’en-tête concerne les deux unités de traduction, même si aucune des deux sources n’a été modifiée. Représente-toi les fichiers d’entrée alimentant les fichiers objets, puis les fichiers objets alimentant l’exécutable. Les modifications se propagent selon ces relations enregistrées.

Inclure les dépendances aux fichiers d’en-tête

La règle incomplète main.o: main.c ne tient pas compte des modifications de convert.h. Make ne lit pas le code source C pour découvrir les inclusions ; il suit les dépendances déclarées. Liste les fichiers d’en-tête inclus ou charge les fichiers de dépendances générés par le compilateur pour éviter de lier des fichiers objets périmés.

Regrouper les opérations dépendantes de l’interpréteur

Des lignes de recette distinctes utilisent normalement des interpréteurs distincts. Une ligne contenant uniquement cd build ne change pas le répertoire de la ligne suivante. Utilise une seule commande comme cd build && gcc -c ../main.c lorsque la compilation dépend de ce changement de répertoire. Prévisualise les recettes prévues avec make -n.

Les variables et les règles de motif éliminent les répétitions de commandes du compilateur tout en préservant le graphe de dépendances. Dans les exemples, chaque recette est placée après un point-virgule sur la ligne de sa règle. Ne raccourcis un makefile qu’une fois ses relations de compilation correctes.

Nommer les paramètres partagés

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g
OBJS = main.o convert.o

temp: $(OBJS); $(CC) $(CFLAGS) -o $@ $^

%.o: %.c convert.h; $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

.PHONY: clean
clean:; rm -f temp $(OBJS)

$(CC) développe la variable du compilateur ; $(CFLAGS) développe ses options. CPPFLAGS contient par convention les options du préprocesseur comme -DDEBUG ou -Iinclude. Les options -Wall -Wextra activent les avertissements, -g ajoute des informations de débogage et -O2 active l’optimisation. Les variables make non définies se développent en texte vide. Écris $(CC) et non $CC : cette dernière écriture désigne la variable à une lettre C, suivie d’un C littéral.

Lire les variables automatiques dans une règle

Pour main.o, le radical du motif est main : %.c devient donc main.c. La recette de compilation utilise $< pour transmettre cette source au compilateur et $@ pour nommer main.o. Le fichier d’en-tête est une dépendance, mais il n’est pas transmis comme autre entrée de compilation.

Dans la règle d’édition de liens, toutes les dépendances sont des fichiers objets. $^ se développe en main.o convert.o et $@ devient temp. Utiliser $< à cet endroit ne transmettrait que main.o, en perdant les définitions de convert.o.

GNU make possède des règles prédéfinies qui peuvent compiler x.c en x.o à l’aide de CC, CPPFLAGS et CFLAGS. Une règle de dépendance explicite sans recette peut utiliser cette recette prédéfinie. GNU make peut même construire un programme simple avec make hello à partir de hello.c sans makefile.

Marquer les cibles d’action comme factices

clean désigne une action, non un fichier à créer. .PHONY: clean garantit l’exécution de l’action même si un fichier nommé clean existe. rm -f accepte que des fichiers soient déjà absents. Une cible all qui regroupe plusieurs programmes est généralement factice elle aussi.

Générer les listes de fichiers d’en-tête et examiner les reconstructions

Ajoute -MMD -MP aux options de compilation pour écrire un fichier .d à côté de chaque fichier objet. -MMD enregistre les dépendances aux fichiers d’en-tête utilisateur ; -MP ajoute des règles vides qui facilitent la gestion de la suppression d’un fichier d’en-tête enregistré. Après la cible par défaut ordinaire, charge les listes avec :

-include $(OBJS:.o=.d)

La substitution transforme les noms des fichiers objets en noms de fichiers de dépendances. Le signe moins initial autorise l’absence de fichiers .d lors de la première compilation. Supprime ces fichiers générés dans clean avec les fichiers objets.

make -n prévisualise les commandes, make -B force la reconstruction et make -j4 permet d’exécuter jusqu’à quatre recettes à la fois. Des dépendances correctes sont aussi importantes pour les compilations parallèles. Modifier uniquement le texte de CFLAGS ne rend pas les fichiers objets existants plus anciens qu’une dépendance. Après avoir modifié les options, utilise make -B ou effectue une reconstruction après nettoyage pour que chaque fichier objet utilise les nouveaux paramètres.