Réponse.

Les macros du préprocesseur en C sont apparues comme une partie du langage pour garantir la portabilité, la lisibilité et la configurabilité du code source. Avec les directives #define, #ifdef, #ifndef, on peut créer des sections conditionnelles de code, déclarer des constantes et inclure des fichiers externes (#include).

Historique de la question :

Les directives du préprocesseur ont été introduites pour simplifier l'adaptation du code source sur différentes systèmes et compilateurs, ainsi que pour automatiser les actions répétitives.

Problème :

Sans préprocesseur, il était impossible de s’abstraire des différences de plateforme, de répéter des fragments de code, de se protéger contre l'inclusion multiple de fichiers d'en-tête. De plus, il faut être prudent, car les macros ne sont pas typées et n'ont pas de portée.

Solution :

Utilisation des macros du préprocesseur pour déclarer des constantes, des fonctions en ligne, la compilation conditionnelle et éviter l'inclusion multiple des fichiers d'en-tête.

Exemple de code :

#ifndef MY_HEADER_H
#define MY_HEADER_H

#define MAX_SIZE 100

#ifdef DEBUG
    #define LOG(x) printf("%s\n", x)
#else
    #define LOG(x)
#endif

#endif /* MY_HEADER_H */

Caractéristiques clés :

Les macros ne sont pas soumises à la vérification des types par le compilateur
#ifdef/#ifndef permettent de créer un code portable et paramétrable
#include protégé contre l'inclusion multiple à l'aide de guards d'inclusion

Questions pièges.

Que se passe-t-il si l'on oublie les guards d'inclusion dans un fichier d'en-tête ?

Le fichier d'en-tête peut être inclus plusieurs fois dans un fichier .c (implicitement via d'autres .h), ce qui entraînera des erreurs de redéfinition.

Quelle est la différence entre #define d'une macro et la déclaration d'une fonction inline ?

#define remplace simplement le texte sans vérifier les types et la syntaxe correcte, tandis qu'une fonction inline est une fonction ordinaire, vérifiée par le compilateur au moment de l'analyse des types.

Les macros peuvent-elles avoir des effets secondaires ?

Oui, si une macro est mal définie, les expressions passées peuvent être évaluées plusieurs fois. Par exemple :

#define SQUARE(x) (x) * (x)
int a = SQUARE(++i); // ++i sera exécuté DEUX FOIS !

Erreurs typiques et anti-patrons

Macros avec effets secondaires et logique ambiguë
Absence de directives de protection (include guards) dans les fichiers d'en-tête
Utilisation de macros pour des actions complexes, au lieu de fonctions

Exemple de la vie réelle

Cas négatif

Utilisation d'une macro sans parenthèses et avec une expression créant des effets secondaires :

#define DOUBLE(x) x + x
int result = DOUBLE(1+2); // le résultat n'est pas 6, mais 1+2+1+2=6? Non, c'est 1+2+1+2=6 — n'est-ce pas ? Non, ça fait 1+2+1+2.
// Mais en réalité, ce sera 1 + 2 + 1 + 2 = 6, mais si DOUBLE(++i), alors ++i sera appliqué deux fois.

Avantages :

Écriture courte

Inconvénients :

Erreurs dues à un ordre de calcul incorrect, effets secondaires

Cas positif

Définition d'une macro avec des parenthèses et utilisation pour des constantes simples :

#define DOUBLE(x) ((x) + (x))
#define BUFFER_SIZE 1024