Replacing text macros

Le préprocesseur prend en charge le remplacement de macros textuelles et le remplacement de macros textuelles de type fonction.

Syntaxe

Explication

#define directives

Les directives #define définissent l' identifiant comme une macro, c'est-à-dire qu'elles indiquent au compilateur de remplacer toutes les occurrences successives de l' identifiant par la liste-de-remplacement , qui peut éventuellement être traitée supplémentairement. Si l'identifiant est déjà défini comme un quelconque type de macro, le programme est mal formé sauf si les définitions sont identiques.

Macros de type objet

Les macros de type objet remplacent chaque occurrence d'un identifiant défini par une liste-de-remplacement . La version (1) de la directive #define se comporte exactement de cette manière.

Macros de type fonction

Les macros de type fonction remplacent chaque occurrence d'un identifiant défini par une liste-de-remplacement , en prenant également un certain nombre d'arguments qui remplacent ensuite les occurrences correspondantes des paramètres dans la liste-de-remplacement .

La syntaxe d'un appel de macro de type fonction est similaire à la syntaxe d'un appel de fonction : chaque occurrence du nom de la macro suivie d'un ( comme prochain jeton de préprocesseur introduit la séquence de jetons qui est remplacée par la liste de remplacement. La séquence se termine par le jeton ) correspondant, en sautant les paires correspondantes de parenthèses gauches et droites intermédiaires.

Le nombre d'arguments doit être le même que le nombre d'arguments dans la définition de la macro ( parameters ) ou le programme est mal formé. Si l'identifiant n'est pas en notation fonctionnelle, c'est-à-dire s'il n'a pas de parenthèses après lui-même, il n'est pas remplacé du tout.

La version (2) de la directive #define définit une macro simple de type fonction.

La version (3) de la directive #define définit une macro de type fonction avec un nombre variable d'arguments. Les arguments supplémentaires peuvent être accédés en utilisant l'identifiant __VA_ARGS__ , qui est ensuite remplacé par les arguments fournis avec l'identifiant à remplacer.

La version (4) de la directive #define définit une macro de type fonction avec un nombre variable d'arguments, mais sans arguments réguliers. Les arguments ne peuvent être accédés qu'avec l'identifiant __VA_ARGS__ , qui est ensuite remplacé par les arguments fournis avec l'identifiant à remplacer.

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)
F(a, b, c) // replaced by f(0, a, b, c)
F()        // replaced by f(0)
#define G(X, ...) f(0, X __VA_OPT__(,) __VA_ARGS__)
G(a, b, c) // replaced by f(0, a, b, c)
G(a, )     // replaced by f(0, a)
G(a)       // replaced by f(0, a)
#define SDEF(sname, ...) S sname __VA_OPT__(= { __VA_ARGS__ })
SDEF(foo);       // replaced by S foo;
SDEF(bar, 1, 2); // replaced by S bar = { 1, 2 };

Remarque : si un argument d'une macro de type fonction contient des virgules qui ne sont pas protégées par des paires de parenthèses gauche et droite correspondantes (telles que macro ( array [ x = y, x + 1 ] ) ou atomic_store ( p, ( struct S ) { a, b } ) ; ), la virgule est interprétée comme un séparateur d'arguments de macro, provoquant une erreur de compilation due à une inadéquation du nombre d'arguments.

# et ## opérateurs

Dans les macros de type fonction, un opérateur # placé devant un identifiant dans la replacement-list soumet cet identifiant au remplacement des paramètres et encadre le résultat de guillemets, créant ainsi effectivement un littéral de chaîne. De plus, le préprocesseur ajoute des barres obliques inverses pour échapper les guillemets entourant les littéraux de chaîne intégrés, le cas échéant, et double les barres obliques inverses dans la chaîne si nécessaire. Tous les espaces blancs de début et de fin sont supprimés, et toute séquence d'espaces blancs au milieu du texte (mais pas à l'intérieur des littéraux de chaîne intégrés) est réduite à un seul espace. Cette opération est appelée « stringification ». Si le résultat de la stringification n'est pas un littéral de chaîne valide, le comportement est indéfini.

#define showlist(...) puts(#__VA_ARGS__)
showlist();            // expands to puts("")
showlist(1, "x", int); // expands to puts("1, \"x\", int")

Un ## opérateur entre deux identifiants successifs dans la liste-de-remplacement effectue le remplacement des paramètres sur les deux identifiants puis concatène le résultat. Cette opération est appelée « concaténation » ou « collage de jetons ». Seuls les jetons qui forment ensemble un jeton valide peuvent être collés : des identifiants formant un identifiant plus long, des chiffres formant un nombre, ou les opérateurs + et = qui forment un += . Un commentaire ne peut pas être créé en collant / et * car les commentaires sont supprimés du texte avant que la substitution des macros ne soit considérée. Si le résultat de la concaténation n'est pas un jeton valide, le comportement est indéfini.

Note : Certains compilateurs proposent une extension qui permet à ## d'apparaître après une virgule et avant __VA_ARGS__ , auquel cas le ## ne fait rien lorsque __VA_ARGS__ n'est pas vide, mais supprime la virgule lorsque __VA_ARGS__ est vide : cela permet de définir des macros telles que fprintf ( stderr , format, ##__VA_ARGS__) .

L'ordre d'évaluation des opérateurs # et ## n'est pas spécifié.

#undef directive

La directive #undef supprime la définition de l' identifiant , c'est-à-dire qu'elle annule la définition précédente de l' identifiant par la directive #define . Si l'identifiant n'a pas de macro associée, la directive est ignorée.

Macros prédéfinies

Les noms de macro suivants sont prédéfinis dans toute unité de traduction :

Les noms de macro supplémentaires suivants peuvent être prédéfinis par une implémentation :

Les valeurs de ces macros (à l'exception de __FILE__ et __LINE__ ) restent constantes tout au long de l'unité de traduction. Toute tentative de redéfinir ou de supprimer ces macros entraîne un comportement indéfini.

Exemple

#include <stdio.h>
// make function factory and use it
#define FUNCTION(name, a) int fun_##name(int x) { return (a) * x; }
FUNCTION(quadruple, 4)
FUNCTION(double, 2)
#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) puts( #a )
int main(void)
{
    printf("quadruple(13): %d\n", fun_quadruple(13));
    printf("double(21): %d\n", fun_double(21));
    printf("%d\n", FUNCTION);
    OUTPUT(billion); // note the lack of quotes
}

quadruple(13): 52
double(21): 42
34
billion

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C publiées précédemment.

Références

Voir aussi