Como faço para mostrar o valor de um #define em tempo de compilação?

Estou tentando descobrir qual versão do Boost meu código pensa que está usando. Eu quero fazer algo assim:

#error BOOST_VERSION

mas o pré-processador não expande BOOST_VERSION.

Eu sei que poderia imprimi-lo em tempo de execução a partir do programa e sei que poderia olhar a saída do pré-processador para encontrar a resposta. Acho que ter uma maneira de fazer isso durante a compilação pode ser útil.

Eu sei que isso é muito tempo depois da consulta original, mas ainda pode ser útil.

Isso pode ser feito no GCC usando o operador stringify "#", mas requer dois estágios.

#define XSTR(x) STR(x)
#define STR(x) #x

O valor de uma macro pode então ser exibido com:

#pragma message "The value of ABC: " XSTR(ABC)

Veja: 3.4 Stringificação na documentação online do gcc.

Como funciona:

O pré-processador entende strings entre aspas e as trata de maneira diferente do texto normal. A concatenação de strings é um exemplo desse tratamento especial. O pragma da mensagem requer um argumento que é uma string entre aspas. Quando há mais de um componente para o argumento, todos eles devem ser strings para que a concatenação de strings possa ser aplicada. O pré-processador nunca pode assumir que uma string sem aspas deva ser tratada como se estivesse entre aspas. Se sim, então:

#define ABC 123
int n = ABC;

não compilaria.

Agora considere:

#define ABC abc
#pragma message "The value of ABC is: " ABC

que é equivalente a

#pragma message "The value of ABC is: " abc

Isso causa um aviso do pré-processador porque abc (sem aspas) não pode ser concatenado com a string anterior.

Agora considere o pré-processador stringize (que já foi chamado de stringification, os links na documentação foram alterados para refletir a terminologia revisada. (Ambos os termos, aliás, são igualmente detestáveis. O termo correto é, obviamente, stringifaction. Esteja pronto para atualizar seus links.)) operador. Isso atua apenas nos argumentos de uma macro e substitui o argumento não expandido pelo argumento entre aspas duplas. Portanto:

#define STR(x) #x
char *s1 = "abc";
char *s2 = STR(abc);

irá atribuir valores idênticos a s1 e s2. Se você executar gcc -E, poderá ver isso na saída. Talvez STR fosse melhor denominado algo como ENQUOTE.

Isso resolve o problema de colocar aspas em torno de um item não cotado, o problema agora é que, se o argumento for uma macro, a macro não será expandida. É por isso que a segunda macro é necessária. O XSTR expande seu argumento e chama STR para colocar o valor expandido entre aspas.

BOOST_PP_STRINGIZE parece uma solução excelente para C ++, mas não para C.

Aqui está minha solução para GNU CPP:

/* Some test definition here */
#define DEFINED_BUT_NO_VALUE
#define DEFINED_INT 3
#define DEFINED_STR "ABC"

/* definition to expand macro then apply to pragma message */
#define VALUE_TO_STRING(x) #x
#define VALUE(x) VALUE_TO_STRING(x)
#define VAR_NAME_VALUE(var) #var "="  VALUE(var)

/* Some example here */
#pragma message(VAR_NAME_VALUE(NOT_DEFINED))
#pragma message(VAR_NAME_VALUE(DEFINED_BUT_NO_VALUE))
#pragma message(VAR_NAME_VALUE(DEFINED_INT))
#pragma message(VAR_NAME_VALUE(DEFINED_STR))

As definições acima resultam em:

test.c:10:9: note: #pragma message: NOT_DEFINED=NOT_DEFINED
test.c:11:9: note: #pragma message: DEFINED_BUT_NO_VALUE=
test.c:12:9: note: #pragma message: DEFINED_INT=3
test.c:13:9: note: #pragma message: DEFINED_STR="ABC"

Para variáveis "definidas como interger" , "definidas como string" e "definidas mas sem valor" , elas funcionam muito bem. Apenas para a variável "não definida" , eles exibiram exatamente o mesmo que o nome da variável original. Você tem que se acostumar - ou talvez alguém possa fornecer uma solução melhor.

Se estiver usando Visual C ++, você pode usar #pragma message:

#include <boost/preprocessor/stringize.hpp>
#pragma message("BOOST_VERSION=" BOOST_PP_STRINGIZE(BOOST_VERSION))

Edit: Obrigado a LB pelo link

Aparentemente, o equivalente GCC é (não testado):

#pragma message "BOOST_VERSION=" BOOST_PP_STRINGIZE(BOOST_VERSION)

Pelo que eu sei, '#error' apenas imprimirá strings, na verdade você nem precisa usar aspas .

Você já tentou escrever vários códigos propositalmente incorretos usando "BOOST_VERSION"? Talvez algo como "blá [BOOST_VERSION] = foo;" dirá algo como "string literal 1.2.1 não pode ser usado como endereço de array". Não será uma mensagem de erro bonita, mas pelo menos mostrará o valor relevante. Você pode brincar até encontrar um erro de compilação que informe o valor.

Sem impulso:

1. defina a mesma macro novamente e o compilador HIMSELF dará um aviso.

2. A partir do aviso, você pode ver a localização da definição anterior.

3. arquivo vi de definição anterior.

ambarish@axiom:~/cpp$ g++ shiftOper.cpp
shiftOper.cpp:7:1: warning: "LINUX_VERSION_CODE" redefined
shiftOper.cpp:6:1: warning: this is the location of the previous definition

#define LINUX_VERSION_CODE 265216
#define LINUX_VERSION_CODE 666

int main ()
{

}

No Microsoft C / C ++, você pode usar o interno _CRT_STRINGIZE()para imprimir constantes. Muitos dos meus stdafx.harquivos contêm alguma combinação destes:

#pragma message("_MSC_VER      is " _CRT_STRINGIZE(_MSC_VER))
#pragma message("_MFC_VER      is " _CRT_STRINGIZE(_MFC_VER))
#pragma message("_ATL_VER      is " _CRT_STRINGIZE(_ATL_VER))
#pragma message("WINVER        is " _CRT_STRINGIZE(WINVER))
#pragma message("_WIN32_WINNT  is " _CRT_STRINGIZE(_WIN32_WINNT))
#pragma message("_WIN32_IE     is " _CRT_STRINGIZE(_WIN32_IE))
#pragma message("NTDDI_VERSION is " _CRT_STRINGIZE(NTDDI_VERSION)) 

e produz algo como este:

_MSC_VER      is 1915
_MFC_VER      is 0x0E00
_ATL_VER      is 0x0E00
WINVER        is 0x0600
_WIN32_WINNT  is 0x0600
_WIN32_IE     is 0x0700
NTDDI_VERSION is 0x06000000

#define a <::BOOST_VERSION>
#include a

MSVC2015 : erro fatal C1083: Não é possível abrir arquivo de inclusão: ':: 106200': Não existe esse arquivo ou diretório

Funciona mesmo se preprocess to fileestiver ativado, mesmo se tokens inválidos estiverem presentes:

#define a <::'*/`#>
#include a

MSVC2015 : erro fatal C1083: Não é possível abrir arquivo de inclusão: '::' * / `# ': Não
existe esse arquivo ou diretório GCC4.x : aviso: falta de terminação' caractere [-Winvalid-pp-token]
#define a <:: '* / `#>

Você também pode pré-processar o arquivo de origem e ver como o valor do pré-processador é avaliado.

Você está procurando

#if BOOST_VERSION != "1.2"
#error "Bad version"
#endif

Não é ótimo se BOOST_VERSION for uma string, como assumi, mas também pode haver inteiros individuais definidos para os números principais, secundários e de revisão.

Olhar para a saída do pré-processador é a coisa mais próxima da resposta que você pede.

Eu sei que você excluiu isso (e outras formas), mas não tenho certeza do porquê. Você tem um problema específico o suficiente para resolver, mas não explicou por que algum dos métodos "normais" não funciona bem para você.

Você pode escrever um programa que imprima, BOOST_VERSIONcompile e execute-o como parte de seu sistema de construção. Caso contrário, acho que você está sem sorte.

BOOST_VERSION é definido no arquivo de cabeçalho boost version.hpp.

Dê uma olhada na documentação do Boost também, sobre como você está usando a macro:

Em referência a BOOST_VERSION, de http://www.boost.org/doc/libs/1_37_0/libs/config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.boost_helper_macros :

Descreve o número da versão ampliada no formato XXYYZZ de modo que: (BOOST_VERSION % 100)é a versão subsecundária , é a versão secundária e é a versão principal.((BOOST_VERSION / 100) % 1000)(BOOST_VERSION / 100000)

Em vez de #error, tente redefinir a macro, pouco antes de ser usada. A compilação falhará e o compilador fornecerá o valor atual que ele pensa que se aplica à macro.

#define BOOST_VERSION blah