Partager via

#if, #elif, #else, et directives de #endif (C/C++)

  • Article

La directive d' #if , avec #elif, #else, les directives et d' #endif , contrôle la compilation des parties d'un fichier source.Si l'expression que vous écrivez (après qu' #if) a une valeur différente de zéro, le groupe de ligne située immédiatement après la directive d' #if est conservée dans l'unité de traduction.

Grammaire

  • conditionnel :
    elif-partselse-partendif-ligneoptoptde si-partie

  • si-partie :
    texte de si-ligne

  • si-ligne :
    expression constante de**#if**

    identificateur de**#ifdef**

    identificateur de**#ifndef**

  • elif-parties :
    texte d'elif-ligne

    texte d'elif-ligne d'elif-parties

  • elif-ligne :
    expression constante de**#elif**

  • d'autre-partie :
    texte d ' autre-ligne

  • d'autre-ligne :
    #else

  • endif-ligne :
    #endif

Chaque directive d' #if dans un fichier source doit être mise en correspondance par une directive fermante d' #endif .Plusieurs directives d' #elif peuvent apparaître entre #if et les directives d' #endif , mais au plus une directive d' #else est autorisée.La directive d' #else , le cas échéant, doit être la dernière directive avant #endif.

#if, #elif, #else, puis les directives d' #endif peuvent s'imbriquer dans les parties de texte d'autres directives d' #if .Chaque a imbriqué #else, #elif, la directive ou d' #endif appartient à la directive d' #if précédente la plus proche.

Les directives de compilation conditionnelle, telles que #if et #ifdef, doivent correspondre à fermer les directives d' #endif avant la fin du fichier ; sinon, un message d'erreur est générée.Lorsque des directives de compilation conditionnelle sont contenues dans les fichiers Include, elles doivent remplir les mêmes conditions : Il ne doit y avoir aucune directive sans correspondance de compilation conditionnelle à la fin de le fichier Include.

La macro remplacement est effectué dans la partie de la ligne de commande qui suit une commande d' #elif , une macro-instruction peut être utilisée dans l'expression constante.

Le préprocesseur sélectionne une des occurrences données de texte pour un traitement supplémentaire.Un bloc spécifié dans le texte peut être une séquence de texte.Il peut occuper plusieurs lignes.Généralement le texte est un texte de programme qui est significative au compilateur ou au préprocesseur.

le préprocesseur traite le texte sélectionné et le passe au compilateur.Si le texte contient des directives de préprocesseur, le préprocesseur exécute ces directives.Seuls les blocs de texte sélectionné par le préprocesseur sont compilés.

Le préprocesseur sélectionne un élément unique de texte pour évaluer l'expression constante suivant chaque directive d' #if ou d' #elif jusqu'à ce qu'il trouve une expression constante (différente de zéro) true.Il sélectionne tout le texte (autres directives de préprocesseur y compris en commençant par #) jusqu'à son #elif, #else, ou #endifassocié.

Si toutes les occurrences d'expression constante sont réalisées, ou si directive d' #elif n'apparaît pas, le préprocesseur sélectionne le bloc de texte après la clause d' #else .Si la clause d' #else est ignorée et toutes les instances d'expression constante dans le bloc d' #if sont réalisées, aucun bloc de texte n'est sélectionné.

l'expression constante est une expression constante entière avec ces restrictions supplémentaires :

  • Les expressions doivent être de type intégral et peuvent inclure uniquement les constantes entières, les constantes caractère, et l'opérateur de défini .

  • l'expression ne peut pas utiliser sizeof ou un opérateur de cast de type.

  • L'environnement cible ne soit pas capable de représenter toutes les plages d'entiers.

  • la traduction représente le type int les mêmes que le type long, et l' unsigned int les mêmes qu' unsigned long.

  • Le traducteur peut convertir des constantes caractère à un ensemble de valeurs de code différentes de l'ensemble de l'environnement cible.Pour déterminer les propriétés de l'environnement cible, les valeurs de contrôle des macros de LIMITS.H dans une application développée pour l'environnement cible.

  • l'expression ne doit effectuer aucune enquêtes environnementales et doit rester isolée des détails d'implémentation sur l'ordinateur cible.

L'opérateur défini de préprocesseur peut être utilisé dans des expressions constantes spéciales, comme indiqué par la syntaxe suivante :

la valeur ( identifier )

identifierdéfini

Cette expression constante est considérée comme vraie (différent de zéro) si l'identificateur est actuellement défini ; sinon, la condition a la valeur false (0).Un identificateur défini en tant que texte vide est considéré comme défini.la directive de défini peut être utilisée dans #if et une directive d' #elif , mais nulle part ailleurs.

Dans l'exemple suivant, #if et la compilation du contrôle de directives d' #endif d'un d'appels à triple fonction :

#if defined(CREDIT)
    credit();
#elif defined(DEBIT)
    debit();
#else
    printerror();
#endif

l'appel de fonction à credit est compilé si l'identificateur CREDIT est défini.si l'identificateur DEBIT est défini, l'appel de fonction à debit est compilé.Si aucune d'identificateur n'est défini, l'appel à printerror est compilé.Notez qu' CREDIT et credit sont les identificateurs séparés dans C et C++ car leurs cas sont différents.

Les instructions de compilation conditionnelle dans l'exemple suivant supposent une constante symbolique définie précédemment nommée DLEVEL.

#if DLEVEL > 5
    #define SIGNAL  1
    #if STACKUSE == 1
        #define STACK   200
    #else
        #define STACK   100
    #endif
#else
    #define SIGNAL  0
    #if STACKUSE == 1
        #define STACK   100
    #else
        #define STACK   50
    #endif
#endif
#if DLEVEL == 0
    #define STACK 0
#elif DLEVEL == 1
    #define STACK 100
#elif DLEVEL > 5
    display( debugptr );
#else
    #define STACK 200
#endif

le premier bloc d' #if montre deux ensembles d' #ifimbriqué, d' #else, et de directives d' #endif .Premier jeu des directives est traité si DLEVEL > 5 est true.Sinon, les instructions après #sinon sont traités.

Les directives d' #elif et d' #else dans le deuxième exemple sont utilisées pour effectuer l'une des quatre tableau, en fonction de la valeur d' DLEVEL.STACK constant est défini à 0, à 100, ou 200, selon la définition d' DLEVEL.Si DLEVEL est supérieur à 5, puis l'instruction

#elif DLEVEL > 5
display(debugptr);

est compilé et STACK n'est pas défini.

Une utilisation courante pour la compilation conditionnelle permet d'empêcher plusieurs inclusions du même fichier d'en-tête.En C++, où les classes sont souvent définies dans les fichiers d'en-tête, des éléments comme les éléments suivants peuvent être utilisés pour empêcher plusieurs définitions :

/*  EXAMPLE.H - Example header file  */
#if !defined( EXAMPLE_H )
#define EXAMPLE_H

class Example
{
...
};

#endif // !defined( EXAMPLE_H )

Le code précédents pour voir si EXAMPLE_H constante symbolique est défini.Si tel est le cas, le fichier a déjà été inclus et ne doit pas être recyclé.sinon, EXAMPLE_H constant est défini pour marquer EXAMPLE.H comme déjà traité.

Voir aussi

Référence

Directives de préprocesseur