c++ - studio - Portabilidad de la directiva de preprocesador#warning

directivas del preprocesador c++

Question

Sé que la directiva #warning no es estándar C / C ++, pero varios compiladores lo admiten, incluyendo gcc / g ++. Pero para aquellos que no lo admiten, ¿lo ignorarán silenciosamente o provocará una falla en la compilación? En otras palabras, ¿puedo usarlo de forma segura en mi proyecto sin romper la compilación para compiladores que no lo admiten?

Answer 1

Al cambiar de mingw a visual studio, agregué esas líneas a mi encabezado de configuración global. (incluirlo en stdafx.h)

#ifdef __GNUC__
//from https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html
//Instead of put such pragma in code:
//#pragma GCC diagnostic ignored "-Wformat"
//use:
//PRAGMA_GCC(diagnostic ignored "-Wformat")
#define DO_PRAGMA(x) _Pragma (#x)
#define PRAGMA_GCC(x) DO_PRAGMA(GCC #x)
#define PRAGMA_MESSAGE(x) DO_PRAGMA(message #x)
#define PRAGMA_WARNING(x) DO_PRAGMA(warning #x)
#endif //__GNUC__
#ifdef _MSC_VER
/*
#define PRAGMA_OPTIMIZE_OFF __pragma(optimize("", off))
// These two lines are equivalent
#pragma optimize("", off)
PRAGMA_OPTIMIZE_OFF
*/
#define PRAGMA_GCC(x)
// https://support2.microsoft.com/kb/155196?wa=wsignin1.0
#define __STR2__(x) #x
#define __STR1__(x) __STR2__(x)
#define __PRAGMA_LOC__ __FILE__ "("__STR1__(__LINE__)") "
#define PRAGMA_WARNING(x) __pragma(message(__PRAGMA_LOC__ ": warning: " #x))
#define PRAGMA_MESSAGE(x) __pragma(message(__PRAGMA_LOC__ ": message : " #x))
#endif
//#pragma message "message quoted"
//#pragma message message unquoted
//#warning warning unquoted
//#warning "warning quoted"
PRAGMA_MESSAGE(PRAGMA_MESSAGE unquoted)
PRAGMA_MESSAGE("PRAGMA_MESSAGE quoted")
#warning "#pragma warning quoted"
PRAGMA_WARNING(PRAGMA_WARNING unquoted)
PRAGMA_WARNING("PRAGMA_WARNING quoted")

Ahora uso PRAGMA_WARNING (esto necesita ser arreglado)

Lamentablemente, no hay ninguna #pragma warning en gcc, por lo que advierte pragma no especificado.

Dudo que gcc agregue #pragma warning" lugar de Microsoft agregando #warning .

Answer 2

Cabe señalar que MSVC usa la sintaxis:

#pragma message ( "your warning text here" )

La sintaxis usual de #warning genera un error fatal

C1021: invalid preprocessor command ''warning''

por lo que no es portátil para esos compiladores.

Answer 3

En realidad, la mayoría de los compiladores que conozco ignoran las directivas #pragma desconocidas y envían un mensaje de advertencia, por lo que, en el peor de los casos, seguirás recibiendo una advertencia.

Answer 4

Es probable que reciba al menos una advertencia de directiva no reconocida de los compiladores que no reconocen #warning, incluso si el bloque de código no está incluido en su compilación. Eso podría o no tratarse como un error, el compilador podría tratarlo legítimamente como un error, pero muchos serían más laxos.

¿Conoce (puede nombrar) un compilador distinto de GCC / G ++ que proporciona #warning? [ Editado: Sun Solaris 10 (Sparc) y los compiladores de Studio 11 C / C ++ aceptan #warning.]

Answer 5

Es probable que si un compilador no admita #warning, emitirá un error. A diferencia de #pragma, no hay ninguna recomendación de que el preprocesador ignore las directivas que no comprende.

Habiendo dicho eso, he usado compiladores en varias plataformas diferentes (razonablemente comunes) y todas han soportado #warning.

Answer 6

Tuve este problema una vez con un compilador para un procesador Atmel. Y sí generó errores de preprocesador debido al desconocido token #warning.

Lamentablemente, la solución parecía ser convertir todo el árbol fuente para usar el equivalente de #pragma y aceptar que el comportamiento de compilación difería si se utilizaba gcc.