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?Portabilidad de la directiva de preprocesador #warning
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.
En realidad, la mayoría de los compiladores que conozco ignoran las desconocidas directivas #pragma y emite un mensaje de advertencia, por lo que en el peor de los casos, aún recibirá una advertencia.
Sin embargo, #warning no es un #pragma. –
Por alguna razón, leí la pregunta como "advertencia de #pragma" –
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 el estudio de 11 C/C++ compiladores ambos aceptar #WARNING.]
Tenía este problema de una vez con un compilador para un procesador Atmel. Y sí generó errores de preprocesador debido al desconocido token #warning.
Desafortunadamente, 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.
Cabe señalar que MSVC utiliza la sintaxis:
#pragma message ("your warning text here")
La sintaxis habitual #warning genera un error fatal
C1021: invalid preprocessor command 'warning'
por lo que no es portátil a esos compiladores.
Este es uno de los pocos casos en que MS hace las cosas de la manera correcta. – doc
¿La sintaxis MSVC es portátil? Quiero decir, ¿generaría correctamente una advertencia con otros compiladores? –
Simplemente ejecuté una comprobación rápida usando gcc-4.7.2. [$ gcc -c -Werror file.c] produce [file.c: 10: 9: note: #pragma message: Foo bar baz] De modo que produce una "nota" que no se trata como una advertencia (es decir, no lo hace) t falla la construcción con -Werror habilitado). Pero parece analizar correctamente (como todos los #pragmas), así que es portátil en ese sentido. – nolandda
Al cambiar de mingw a visual studio, agregué tales líneas a mi encabezado de configuración global. (Incluirlo en stdafx.hy)
#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 (esta necesidad de ser fijado)
Lamentablemente no hay #pragma warning en gcc, por lo que advierte pragma no especificado.
Dudo que gcc agregue #pragma warning" en lugar de Microsoft agregando #warning.
Aparentemente, nunca probó MS Visual Studio Professional 2015 ;-). –
@ PeterA.Schneider: ¡Ciertamente en 2008 no lo había hecho! –