Compartilhar via

Diretivas # if, # else, a # elif e # endif (C/C++)

  • Artigo

O #if diretiva com o #elif, #else, e #endif diretivas, compilação de controles de partes de um arquivo de origem.Se a expressão que você escrever (após a #if) tem um valor diferente de zero, o grupo de linha imediatamente seguinte a #if diretiva é mantida na unidade de conversão.

Gramática

  • condicional :
    IF-parte elif peçasoptoutra parteoptendif linha

  • parte-se :
    texto de linha if

  • linha if :
    # IF expressão de constante

    # ifdef identificador

    # ifndef identificador

  • peças elif :
    texto de linha elif

    texto de linha elif de peças elif

  • linha elif :
    # elif expressão de constante

  • outra parte :
    outra linha de texto

  • outra linha :
    #else

  • linha endif :
    #endif

Cada #if diretiva em um arquivo de origem deve ser correspondida por um fechamento #endif diretiva.Qualquer número de #elif diretivas podem aparecer entre os #if e #endif diretivas, mas no máximo uma #else diretiva é permitida.O #else diretiva, se presente, deve ser a última diretiva antes de #endif.

O #if, #elif, #else, e #endif diretivas podem aninhar nas partes de texto dos outros #if diretivas.Cada aninhado #else, #elif, ou #endif diretiva pertence a precedente mais próximo #if diretiva.

Todas as diretivas de compilação condicional, tais como #if e # ifdef, ser correspondida com fechamento #endif as diretivas de antes do fim do arquivo; Caso contrário, uma mensagem de erro é gerada.Quando as diretivas de compilação condicional estão contidas em arquivos de inclusão, eles devem satisfazer as mesmas condições: não deve haver nenhum incomparáveis diretivas de compilação condicional no final do arquivo de inclusão.

Substituição de macro é executada dentro da parte da linha de comando que segue um #elif de comando, portanto, uma chamada de macro pode ser usada na expressão de constante.

O pré-processador seleciona uma das ocorrências de determinada texto para processamento posterior.Um bloco especificado em texto pode ser qualquer seqüência de texto.Ele pode ocupar mais de uma linha.Em geral texto é o texto de programa que tem significado para o compilador ou o pré-processador.

O pré-processador processa selecionado texto e passa para o compilador.Se texto contém diretivas de pré-processamento, a pré-processador executa essas diretivas.Somente os blocos de texto selecionados no pré-processador são compilados.

O pré-processador seleciona um único texto item por meio da avaliação da expressão de constante após cada #if ou #elif diretiva até encontrar uma expressão de constante verdadeira (diferente de zero).Ele seleciona todo o texto (inclusive outras diretivas de pré-processamento começando com #) até seu associado #elif, #else, ou #endif.

Se todas as ocorrências do expressão de constante são falsos, ou se não há #elif diretivas aparecer, o pré-processador seleciona o bloco de texto após a #else cláusula.Se a #else cláusula for omitida e todas as instâncias de expressão de constante na #if bloco são falsos, nenhum bloco de texto é selecionado.

O expressão de constante é uma expressão de constante de inteiro com essas restrições adicionais:

  • Expressões deve ter um tipo integral e pode incluir somente constantes de inteiro, constantes de caractere e o definida pelo operador.

  • A expressão não é possível usar sizeof ou um operador de conversão de tipo.

  • O ambiente de destino não pode ser capaz de representar todos os intervalos de números inteiros.

  • A tradução representa o tipo de int o mesmo tipo de longo, e unsigned int o mesmo que unsigned long.

  • O tradutor pode traduzir constantes de caractere a um conjunto de valores de código diferentes do conjunto para o ambiente de destino.Para determinar as propriedades do ambiente de destino, verifique os valores de macros de limites.H em um aplicativo criado para o ambiente de destino.

  • A expressão não deve executar quaisquer consultas ambientais e deve permanecer isolada dos detalhes de implementação no computador de destino.

O operador pré-processador definida pelo pode ser usado em expressões constantes especiais, como mostra a seguinte sintaxe:

defined( identifier )

definidoidentifier

Essa expressão constante é considerada VERDADEIRO (diferente de zero) se o identificador está definido atualmente; Caso contrário, a condição for falsa (0).Um identificador definido como o texto vazio é considerado definida.O definida pelo diretiva pode ser usada em um #if e um #elif diretiva, mas em nenhum outro lugar.

No exemplo a seguir, o #if e #endif diretivas controlam a compilação de um dos três chamadas de função:

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

A chamada de função para credit é compilado, se o identificador CREDIT está definido.Se o identificador DEBIT for definida, a chamada de função para debit é compilado.Se nenhum identificador for definida, a chamada para printerror é compilado.Observe que CREDIT e credit são identificadores distintas em c e C++, pois seus casos são diferentes.

As instruções de compilação condicional no exemplo a seguir pressupõem uma constante de simbólica definida anteriormente chamada 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

O primeiro #if bloco mostra dois conjuntos de aninhadas #if, #else, e #endif diretivas.O primeiro conjunto de diretivas somente será processado se DLEVEL > 5 é verdadeiro.Caso contrário, as declarações após #else são processadas.

O #elif e #else diretivas no segundo exemplo são usadas para fazer uma das quatro opções, com base no valor de DLEVEL.A constante STACK está definido como 0, 100 ou 200, dependendo da definição de DLEVEL.Se DLEVEL é maior que 5, em seguida, a instrução

#elif DLEVEL > 5
display(debugptr);

é compilado e STACK não está definido.

Um uso comum para compilação condicional é impedir que várias inclusões do mesmo arquivo de cabeçalho.No C++, onde as classes são muitas vezes definidas nos arquivos de cabeçalho, construções semelhante ao seguinte podem ser usadas para impedir que várias definições:

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

class Example
{
...
};

#endif // !defined( EXAMPLE_H )

O código anterior verifica se a constante simbólica EXAMPLE_H está definido.Nesse caso, o arquivo já foi incluído e não precisa ser reprocessado.Se não, a constante EXAMPLE_H é definida para marcar o exemplo.H como já foi processado.

Consulte também

Referência

Diretivas de pré-processador