Portabilité de la directive de préprocesseur #warning
Je sais que la directive #warning n'est pas standard C /C++, mais plusieurs compilateurs la prennent en charge, y compris gcc/g ++. Mais pour ceux qui ne le prennent pas en charge, vont-ils l'ignorer silencieusement ou entraînera-t-il un échec de compilation? En d'autres termes, puis-je l'utiliser en toute sécurité dans mon projet sans interrompre la construction des compilateurs qui ne le prennent pas en charge?
Il est probable que si un compilateur ne prend pas en charge #warning, il émettra une erreur. Contrairement à #pragma, il n'est pas recommandé que le préprocesseur ignore les directives qu'il ne comprend pas.
Cela dit, j'ai utilisé des compilateurs sur différentes plates-formes différentes (raisonnablement courantes) et ils ont tous pris en charge #warning.
Il convient de noter que MSVC utilise la syntaxe:
# message pragma ("votre texte d'avertissement ici")
La syntaxe #warning habituelle génère une erreur fatale
C1021: avertissement de commande de préprocesseur non valide
il n'est donc pas portable pour ces compilateurs.
Vous êtes susceptible d'obtenir au moins un avertissement de directive non reconnu de la part des compilateurs qui ne reconnaissent pas #warning, même si le bloc de code n'est pas inclus dans votre compilation. Cela pourrait ou non être traité comme une erreur - le compilateur pourrait légitimement le traiter comme une erreur, mais beaucoup seraient plus laxistes.
Connaissez-vous (pouvez-vous nommer) un compilateur autre que GCC/G ++ qui fournit #warning? [Modifié: Sun Solaris 10 (Sparc) et les compilateurs Studio 11 C/C++ acceptent tous les deux #warning.]
En passant de mingw à visual studio, j'ai ajouté de telles lignes à mon en-tête de configuration globale. (l'inclure dans 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")
Maintenant, j'utilise PRAGMA_WARNING (cela doit être corrigé)
Malheureusement, il n'y a pas de #pragma warning dans gcc, donc il avertit un pragma non spécifié.
Je doute que gcc ajoute #pragma warning" plutôt que Microsoft ajoutant #warning.
J'ai eu ce problème une fois avec un compilateur pour un processeur Atmel. Et il a généré des erreurs de préprocesseur en raison du jeton #warning inconnu.
Malheureusement, la solution semblait être de convertir l'arborescence source entière pour utiliser l'équivalent #pragma et d'accepter que le comportement de construction allait différer si vous utilisez gcc.
En fait, la plupart des compilateurs que je connais ignorent les directives #pragma inconnues et affichent un message d'avertissement - dans le pire des cas, vous recevrez toujours un avertissement.