¿Cómo muestro el valor de un #define en tiempo de compilación?

Estoy tratando de averiguar qué versión de Boost cree que está usando mi código. Quiero hacer algo como esto:

#error BOOST_VERSION

pero el preprocesador no expande BOOST_VERSION.

Sé que podría imprimirlo en tiempo de ejecución desde el programa y sé que podría mirar la salida del preprocesador para encontrar la respuesta. Siento que tener una forma de hacer esto durante la compilación podría ser útil.

Sé que esto es mucho después de la consulta original, pero aún puede ser útil.

Esto se puede hacer en GCC usando el operador de cadena "#", pero requiere dos etapas.

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

El valor de una macro se puede mostrar con:

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

Consulte: 3.4 Cadena de caracteres en la documentación en línea de gcc.

Cómo funciona:

El preprocesador entiende las cadenas entre comillas y las maneja de manera diferente al texto normal. La concatenación de cadenas es un ejemplo de este tratamiento especial. El pragma del mensaje requiere un argumento que sea una cadena entre comillas. Cuando hay más de un componente en el argumento, todos deben ser cadenas para que se pueda aplicar la concatenación de cadenas. El preprocesador nunca puede asumir que una cadena sin comillas debe tratarse como si estuviera entre comillas. Si lo hizo, entonces:

#define ABC 123
int n = ABC;

no compilaría.

Ahora considere:

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

que es equivalente a

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

Esto provoca una advertencia del preprocesador porque abc (sin comillas) no se puede concatenar con la cadena anterior.

Ahora considere el preprocesador stringize (que una vez se llamó stringificación, los enlaces en la documentación se han cambiado para reflejar la terminología revisada. (Ambos términos, por cierto, son igualmente detestables. El término correcto es, por supuesto, stringifaction. Esté listo para actualizar sus enlaces.)) operador. Esto actúa solo sobre los argumentos de una macro y reemplaza el argumento no expandido con el argumento entre comillas dobles. Así:

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

asignará valores idénticos a s1 y s2. Si ejecuta gcc -E, puede ver esto en la salida. Quizás STR se llamaría mejor algo como ENQUOTE.

Esto resuelve el problema de poner comillas alrededor de un elemento sin comillas, el problema ahora es que, si el argumento es una macro, la macro no se expandirá. Por eso se necesita la segunda macro. XSTR expande su argumento, luego llama a STR para poner el valor expandido entre comillas.

BOOST_PP_STRINGIZE parece una excelente solución para C ++, pero no para C.

Aquí está mi solución 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))

Las definiciones anteriores dan como resultado:

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 las variables "definido como entero" , "definido como cadena" y "definido pero sin valor" , funcionan bien. Solo para la variable "no definida" , se muestran exactamente igual que el nombre de la variable original. Tienes que acostumbrarte, o tal vez alguien pueda proporcionar una mejor solución.

Si está utilizando Visual C ++, puede utilizar #pragma message:

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

Editar: Gracias a LB por el enlace

Aparentemente, el equivalente de GCC es (no probado):

#pragma message "BOOST_VERSION=" BOOST_PP_STRINGIZE(BOOST_VERSION)

Hasta donde yo sé, '#error' solo imprimirá cadenas, de hecho , ni siquiera necesita usar comillas .

¿Ha intentado escribir varios códigos incorrectos a propósito con "BOOST_VERSION"? Quizás algo como "blah [BOOST_VERSION] = foo;" le dirá algo como "el literal de cadena 1.2.1 no se puede utilizar como una dirección de matriz". No será un mensaje de error bonito, pero al menos te mostrará el valor relevante. Puede jugar hasta que encuentre un error de compilación que le indique el valor.

Sin impulso:

1. defina la misma macro nuevamente y el compilador HIMSELF le dará una advertencia.

2. Desde la advertencia puede ver la ubicación de la definición anterior.

3. Archivo vi de definición 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 ()
{

}

En Microsoft C / C ++, puede utilizar el integrado _CRT_STRINGIZE()para imprimir constantes. Muchos de mis stdafx.harchivos contienen alguna combinación de estos:

#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)) 

y genera algo como esto:

_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 : error fatal C1083: no se puede abrir el archivo de inclusión: ':: 106200': no ​​existe ese archivo o directorio

Funciona incluso si preprocess to fileestá habilitado, incluso si hay tokens no válidos:

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

MSVC2015 : error fatal C1083: No se puede abrir el archivo de inclusión: '::' * / `# ': No
existe tal archivo o directorio GCC4.x : advertencia: falta el carácter de terminación' [-Winvalid-pp-token]
#define a <:: '* / `#>

También puede preprocesar el archivo fuente y ver a qué se evalúa el valor del preprocesador.

Estás buscando

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

No es genial si BOOST_VERSION es una cadena, como he asumido, pero también puede haber enteros individuales definidos para los números mayor, menor y de revisión.

Mirar la salida del preprocesador es lo más parecido a la respuesta que pide.

Sé que ha excluido eso (y otras formas), pero no estoy seguro de por qué. Tiene un problema suficientemente específico que resolver, pero no ha explicado por qué ninguno de los métodos "normales" no le funciona bien.

Puede escribir un programa que imprima, BOOST_VERSIONcompile y ejecute como parte de su sistema de compilación. De lo contrario, creo que no tienes suerte.

BOOST_VERSION se define en el archivo de encabezado de boost version.hpp.

Eche un vistazo también a la documentación de Boost, con respecto a cómo está usando la macro:

En referencia 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 :

Describe el número de versión de refuerzo en formato XXYYZZ de manera que: (BOOST_VERSION % 100)es la versión sub-menor, es la versión menor y es la versión principal.((BOOST_VERSION / 100) % 1000)(BOOST_VERSION / 100000)

En lugar de #error, intente redefinir la macro, justo antes de que se utilice. La compilación fallará y el compilador proporcionará el valor actual que cree que se aplica a la macro.

#define BOOST_VERSION bla