#define, directive (C/C++)#define Directive (C/C++)

Le #define crée un macro, qui est l’association d’un identificateur ou un identificateur paramétré avec une chaîne de jeton.The #define creates a macro, which is the association of an identifier or parameterized identifier with a token string. Une fois la macro définie, le compilateur peut substituer la chaîne de jeton pour chaque occurrence de l'identificateur dans le fichier source.After the macro is defined, the compiler can substitute the token string for each occurrence of the identifier in the source file.

SyntaxeSyntax

#define identifier token-stringopt#define identifier token-stringopt

#define identificateur ( identificateuropt , ... , identificateuropt ) chaîne de jetonopt#define identifier ( identifieropt, ... , identifieropt) token-stringopt

NotesRemarks

Le #define directive indique au compilateur de remplacer chaîne de jeton pour chaque occurrence de identificateur dans le fichier source.The #define directive causes the compiler to substitute token-string for each occurrence of identifier in the source file. Le identificateur est remplacé uniquement lorsqu’il forme un jeton.The identifier is replaced only when it forms a token. Autrement dit, identificateur n’est pas remplacé s’il apparaît dans un commentaire, dans une chaîne, ou en tant que partie d’un identificateur plus long.That is, identifier is not replaced if it appears in a comment, in a string, or as part of a longer identifier. Pour plus d’informations, consultez jetons.For more information, see Tokens.

Le chaîne de jeton argument se compose d’une série de jetons, tels que les mots clés, des constantes ou des instructions complètes.The token-string argument consists of a series of tokens, such as keywords, constants, or complete statements. Un ou plusieurs espaces blancs doivent séparer chaîne de jeton de identificateur.One or more white-space characters must separate token-string from identifier. Cet espace blanc n'est pas considéré comme faisant partie du texte substitué, pas plus que tout espace blanc qui suit le dernier jeton du texte.This white space is not considered part of the substituted text, nor is any white space that follows the last token of the text.

Un #define sans un chaîne de jeton supprime les occurrences de identificateur à partir du fichier source.A #define without a token-string removes occurrences of identifier from the source file. Le identificateur reste défini et peut être testé à l’aide de la #if defined et #ifdef directives.The identifier remains defined and can be tested by using the #if defined and #ifdef directives.

La deuxième forme de syntaxe définit une macro de type fonction avec des paramètres.The second syntax form defines a function-like macro with parameters. Cette forme accepte la liste facultative des paramètres qui doivent apparaître entre parenthèses.This form accepts an optional list of parameters that must appear in parentheses. Une fois la macro définie, chaque occurrence suivante de identificateur( identificateuropt,..., identificateur opt ) est remplacé par une version de la chaîne de jeton argument qui a des arguments réels sont remplacés par des paramètres formels.After the macro is defined, each subsequent occurrence of identifier( identifieropt, ..., identifieropt ) is replaced with a version of the token-string argument that has actual arguments substituted for formal parameters.

Les noms de paramètres formels apparaissent dans chaîne de jeton pour marquer les emplacements où les valeurs réelles sont substituées.Formal parameter names appear in token-string to mark the locations where actual values are substituted. Chaque nom de paramètre peut apparaître plusieurs fois dans chaîne de jeton, et les noms peuvent apparaître dans n’importe quel ordre.Each parameter name can appear multiple times in token-string, and the names can appear in any order. Le nombre d'arguments de l'appel doit correspondre au nombre de paramètres de la définition de macro.The number of arguments in the call must match the number of parameters in the macro definition. L'utilisation répandue des parenthèses garantit que les arguments réels complexes sont interprétés correctement.Liberal use of parentheses guarantees that complex actual arguments are interpreted correctly.

Les paramètres formels de la liste sont séparés par des virgules.The formal parameters in the list are separated by commas. Chaque nom contenu dans la liste doit être unique et la liste doit être placée entre parenthèses.Each name in the list must be unique, and the list must be enclosed in parentheses. Aucun espace ne peut séparer identificateur et la parenthèse ouvrante.No spaces can separate identifier and the opening parenthesis. Utilisez la concaténation de ligne : placer une barre oblique inverse (\) immédiatement avant le caractère de saut de ligne, pour les longues directives sur plusieurs lignes de code source.Use line concatenation — place a backslash (\) immediately before the newline character — for long directives on multiple source lines. La portée d’un nom de paramètre formel s’étend vers la nouvelle ligne se termine chaîne de jeton.The scope of a formal parameter name extends to the new line that ends token-string.

Lorsqu’une macro a été définie dans la deuxième forme de syntaxe, les instances textuelles suivantes suivies d’une liste d’arguments indiquent un appel de macro.When a macro has been defined in the second syntax form, subsequent textual instances followed by an argument list indicate a macro call. Les arguments réels qui suivent une instance de identificateur dans le fichier source sont mis en correspondance avec des paramètres formels correspondants dans la définition de macro.The actual arguments that follows an instance of identifier in the source file are matched to the corresponding formal parameters in the macro definition. Chaque paramètre formel dans chaîne de jeton qui n’est pas précédé par un enchaînement (#), de charizing (#@), ou de collage de jeton (##) (opérateur), ou pas suivi par un ## opérateur, est remplacé par l’argument réel correspondant.Each formal parameter in token-string that is not preceded by a stringizing (#), charizing (#@), or token-pasting (##) operator, or not followed by a ## operator, is replaced by the corresponding actual argument. Toutes les macros figurant dans l'argument réel sont développées avant que la directive ne remplace le paramètre formel.Any macros in the actual argument are expanded before the directive replaces the formal parameter. (Les opérateurs sont décrits dans opérateurs de préprocesseur.)(The operators are described in Preprocessor Operators.)

Les exemples suivants de macros comportant des arguments illustrent la deuxième forme de la #define syntaxe :The following examples of macros with arguments illustrate the second form of the #define syntax:

// Macro to define cursor lines
#define CURSOR(top, bottom) (((top) << 8) | (bottom))

// Macro to get a random integer with a specified range
#define getrandom(min, max) \
    ((rand()%(int)(((max) + 1)-(min)))+ (min))

Les arguments avec des effets secondaires provoquent des résultats inattendus générés par les macros.Arguments with side effects sometimes cause macros to produce unexpected results. Un paramètre formel donné peut apparaître plusieurs fois dans chaîne de jeton.A given formal parameter may appear more than one time in token-string. Si ce paramètre formel est remplacé par une expression à effets secondaires, l'expression, avec ses effets secondaires, peut être évaluée plusieurs fois.If that formal parameter is replaced by an expression with side effects, the expression, with its side effects, may be evaluated more than one time. (Consultez les exemples sous opérateurs de collage de jeton (##).)(See the examples under Token-Pasting Operator (##).)

La directive #undef entraîne l'oubli de la définition de préprocesseur d'un identificateur.The #undef directive causes an identifier's preprocessor definition to be forgotten. Consultez la Directive #undef pour plus d’informations.See The #undef Directive for more information.

Si le nom de la macro définie apparaît dans chaîne de jeton (même comme résultat d’une autre expansion macro), il n’est pas développé.If the name of the macro being defined occurs in token-string (even as a result of another macro expansion), it is not expanded.

Une seconde #define pour une macro portant le même nom génère un avertissement, sauf si la deuxième séquence de jeton est identique à la première.A second #define for a macro with the same name generates a warning unless the second token sequence is identical to the first.

Section spécifique à MicrosoftMicrosoft Specific

Microsoft C/C++ vous permet de redéfinir une macro si la nouvelle définition est syntaxiquement identique à la définition d'origine.Microsoft C/C++ lets you redefine a macro if the new definition is syntactically identical to the original definition. En d'autres termes, les deux définitions peuvent avoir des noms de paramètres différents.In other words, the two definitions can have different parameter names. Ce comportement diffère de C ANSI, ce qui nécessite que les deux définitions soient lexicalement identiques.This behavior differs from ANSI C, which requires that the two definitions be lexically identical.

Par exemple, les deux macros suivantes sont identiques, sauf pour les noms de paramètres.For example, the following two macros are identical except for the parameter names. C ANSI n’autorise pas de redéfinition, mais Microsoft C/C++ le compile sans erreur.ANSI C does not allow such a redefinition, but Microsoft C/C++ compiles it without error.

#define multiply( f1, f2 ) ( f1 * f2 )
#define multiply( a1, a2 ) ( a1 * a2 )

En revanche, les deux macros suivantes ne sont pas identiques et généreront un avertissement dans Microsoft C/C++.On the other hand, the following two macros are not identical and will generate a warning in Microsoft C/C++.

#define multiply( f1, f2 ) ( f1 * f2 )
#define multiply( a1, a2 ) ( b1 * b2 )

FIN de la section spécifique à MicrosoftEND Microsoft Specific

Cet exemple illustre la #define directive :This example illustrates the #define directive:

#define WIDTH       80
#define LENGTH      ( WIDTH + 10 )

La première instruction définit l'identificateur WIDTH en tant que constante entière 80, puis définit LENGTH en tant que WIDTH et la constante entière 10.The first statement defines the identifier WIDTH as the integer constant 80 and defines LENGTH in terms of WIDTH and the integer constant 10. Chaque occurrence de LENGTH est remplacée par (WIDTH + 10).Each occurrence of LENGTH is replaced by (WIDTH + 10). Ensuite, chaque occurrence de WIDTH + 10 est remplacée par l'expression (80 + 10).In turn, each occurrence of WIDTH + 10 is replaced by the expression (80 + 10). Les parenthèses autour de WIDTH + 10 sont importantes car elles contrôlent l'interprétation d'instructions telles que :The parentheses around WIDTH + 10 are important because they control the interpretation in statements such as the following:

var = LENGTH * 20;

Après l'étape de prétraitement, l'instruction devient :After the preprocessing stage the statement becomes:

var = ( 80 + 10 ) * 20;

ce qui correspond à 1800.which evaluates to 1800. Sans parenthèses, le résultat est :Without parentheses, the result is:

var = 80 + 10 * 20;

qui prend la valeur 280.which evaluates to 280.

Section spécifique à MicrosoftMicrosoft Specific

Définition des macros et constantes avec le /D option du compilateur a le même effet que d’utiliser un #define directive de préprocesseur au début de votre fichier.Defining macros and constants with the /D compiler option has the same effect as using a #define preprocessing directive at the start of your file. Jusqu'à 30 macros peuvent être définies avec l'option /D.Up to 30 macros can be defined by using the /D option.

FIN de la section spécifique à MicrosoftEND Microsoft Specific

Voir aussiSee also

Directives de préprocesseurPreprocessor Directives