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

L' #define crée une macro, qui est l’Association d’un identificateur ou d’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 identificateur jeton-chaîne OPT#define identifier token-stringopt
#define identificateur ( identificateurOPT , ... , identificateur OPT ) jeton-chaîneOPT#define identifier ( identifieropt, ... , identifieropt ) token-stringopt

NotesRemarks

La directive #define oblige le compilateur à substituer la chaîne de jeton pour chaque occurrence de l' identificateur dans le fichier source.The #define directive causes the compiler to substitute token-string for each occurrence of identifier in the source file. L' identificateur est remplacé uniquement lorsqu’il forme un jeton.The identifier is replaced only when it forms a token. Autrement dit, l' identificateur n’est pas remplacé s’il apparaît dans un commentaire, dans une chaîne ou dans le cadre 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.

L’argument Token-String se compose d’une série de jetons, tels que des 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 Token-String de l' 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 jeton-chaîne supprime les occurrences de l' identificateur dans le fichier source.A #define without a token-string removes occurrences of identifier from the source file. L' identificateur reste défini et peut être testé à l’aide #if defined des directives et. #ifdefThe 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 l' identificateur( identificateurOPT,..., identificateurOPT ) est remplacée par une version de l’argument de chaîne de jeton qui a des arguments réels substitution 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 Token-String 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 la 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 l' identificateur et la parenthèse ouvrante.No spaces can separate identifier and the opening parenthesis. Utiliser la concaténation de ligne: Placez une\barre oblique inverse () juste avant le caractère de saut de ligne, pour les directives longues sur plusieurs lignes sources.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 jusqu’à la nouvelle ligne qui termine Token-String.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 d' identificateur dans le fichier source sont mis en correspondance avec les 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 une chaîne de jeton qui n’est pas précédé d’un opérateur String#(), Charing#@() ou de l’opérateur de collage##de jeton (), ou qui n' ## est pas suivi d’un opérateur, est remplacé par le argument réel.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érateursde préprocesseur.)(The operators are described in Preprocessor operators.)

Les exemples suivants de macros avec arguments illustrent la deuxième forme de la syntaxe #define :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 une 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érateur 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. Pour plus d’informations, consultez la Directive #undef .See The #undef Directive for more information.

Si le nom de la macro définie se produit dans la chaîne de jeton (même suite à 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 deuxième #define pour une macro portant le même nom génère un avertissement à moins que la deuxième séquence de jeton soit 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 la norme ANSI C, qui requiert 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. ANSI C n’autorise pas ce type de redéfinition, mais Microsoft CC++ /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 directive #define :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

La définition des macros et des constantes avec l’option de compilateur /d a le même effet que l’utilisation d’une #define directive de prétraitement 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