#if, #elif, #else, y directivas #endif (C/C++)

la directiva de #if , con #elif, #else, y las directivas de #endif , controla la compilación de partes de un archivo de código fuente.Si la expresión que escribe (después de #if) tiene un valor distinto de cero, el grupo de líneas inmediatamente después de la directiva de #if se conservan en la unidad de traducción.

Gramática

• condicional :
  elif-partselse-partendif-líneaoptoptde la si-parte

• si-parte :
  texto de la si-línea

• si-línea :
  expresión constante de**#if**

  identificador deutilice

  identificador de**#ifndef**

• elif-partes :
  texto de la elif-línea

  texto de la elif-línea de las elif-partes

• elif-línea :
  expresión constante de**#elif**

• otro-parte :
  texto de la otro-línea

• otro-línea :
  #else

• endif-línea :
  #endif

Cada directiva de #if en un archivo de código fuente se debe coincidir con una directiva de cierre de #endif .Cualquier número de directivas de #elif puede producir entre #if y las directivas de #endif , pero como máximo una directiva de #else está permitido.La directiva de #else , si está presente, debe ser la directiva pasada antes de #endif.

#if, #elif, #else, y las directivas de #endif pueden anidar en partes del texto de otras directivas de #if .Cada uno anidado #else, #elif, o la directiva de #endif pertenece a la directiva anterior más cercana de #if .

Todas las directivas de compilación condicional, como #if y utilice, se deben coincidir con las directivas de #endif cerrando antes de fin de archivo; si no, se genera un mensaje de error.Cuando las directivas de compilación condicional se incluyen en archivos de inclusión, deben cumplir las mismas condiciones: No debería haber directivas no coincidentes de la compilación condicional al final del archivo de inclusión.

El reemplazo macro se realiza dentro de la parte de la línea de comandos que sigue un comando de #elif , por lo que una macro-instrucción se puede utilizar en la expresión constante.

El preprocesador selecciona una de las apariciones de texto determinadas para más procesamiento.un bloque especificado en texto puede ser cualquier secuencia de texto.puede ocupar más de una línea.El texto suele ser el texto de programa que tiene significado al compilador o el preprocesador.

El preprocesador procesa el texto seleccionado y lo pasa al compilador.si el texto contiene directivas de preprocesador, el preprocesador realiza esas directivas.Sólo los bloques de texto seleccionado por el preprocesador son compilados.

El preprocesador selecciona un solo elemento de texto evalúa la expresión constante que sigue cada directiva de #if o de #elif hasta que encuentra una expresión constante (cero) real.Selecciona todo el texto (otras directivas de preprocesador incluidos a partir de #) hasta el #elif, #else, o #endifasociado.

Si todas las repeticiones de la expresión constante son false, o si se producen ninguna directiva de #elif , el preprocesador selecciona el bloque de texto después de la cláusula de #else .Si se omite la cláusula de #else y todas las instancias de la expresión constante en el bloque de #if son false, no hay un bloque de texto seleccionado.

la expresión constante es una expresión constante entera con estas restricciones adicionales:

• Las expresiones deben tener el tipo entero y pueden incluir sólo constantes enteras, las constantes de caracteres, y el operador de definido .

• La expresión no puede utilizar sizeof o un operador de conversión de tipo.

• El entorno de destino no pueda representar todos los intervalos de enteros.

• La traducción representa el tipo int igual que Másy, a unsigned int igual que unsigned long.

• El traductor puede traducir constantes de caracteres a un conjunto de valores de código diferentes de conjunto para el entorno de destino.Para determinar las propiedades del entorno de destino, valores protegidos de macros de LIMITS.H en una aplicación compilada para el entorno de destino.

• La expresión no debe realizar ninguna preguntas ambiental y seguir aislada detalles de implementación en el equipo de destino.

El operador definido de preprocesador puede utilizar en expresiones constantes especiales, como muestra la siguiente sintaxis:

definido ( identifier )

identifierdefinido

Esta expresión constante se considera true (cero) si el identificador está definido; si no, la condición es false (0).Un identificador definido como texto vacío se considera definida.La directiva de definido se puede utilizar en #if y una directiva de #elif , pero en otra parte.

En el ejemplo siguiente, las directivas de #if y de #endif controlan la compilación de una de las llamadas de función triple:

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

La llamada a credit es compilada si el identificador CREDIT está definido.Si el identificador DEBIT está definido, la llamada a debit es compilada.Si ninguno de los dos identificadores está definido, la llamada a printerror es compilada.Observe que CREDIT y credit son identificadores distintos en C y C++ porque los casos son diferentes.

Las instrucciones de compilación condicional en el ejemplo siguiente se supone una constante simbólica definido previamente denominada 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

El primer bloque de #if muestra dos conjuntos de #ifanidadas, de #else, y de directivas de #endif .El primer conjunto de directivas se procesa solo si DLEVEL > 5 es true.si no, las instrucciones después de # se procesa.

Las directivas de #elif y de #else en el segundo ejemplo se utilizan para realizar una de cuatro decisiones, según el valor de DLEVEL.STACK constante se establece en 0, 100, o 200, dependiendo de la definición de DLEVEL.Si DLEVEL es mayor que 5, la instrucción

#elif DLEVEL > 5
display(debugptr);

se compila y STACK no está definido.

Un uso común para la compilación condicional es evitar inclusiones múltiples del mismo archivo de encabezado.En C++, donde a menudo define las clases en archivos de encabezado, crea el siguiente se pueden utilizar para evitar varias definiciones:

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

class Example
{
...
};

#endif // !defined( EXAMPLE_H )

El código comprueba anteriores para ver si EXAMPLE_H constante simbólico es definido.Si es así el archivo se ha incluido y no necesita ya volver a procesar.Si no, EXAMPLE_H constante es definido marcar EXAMPLE.H como procesado ya.

Vea también

Referencia

Directivas de preprocesador