C/C++ pragma en définir la macro

Question

est-il un moyen pour intégrer pragma déclaration en macro avec d'autres états?

Je suis en train de réaliser quelque chose comme:

#define DEFINE_DELETE_OBJECT(type)                      \
    void delete_ ## type_(int handle);                  \
    void delete_ ## type(int handle);                                                \
    #pragma weak delete_ ## type_ = delete_ ## type

Je suis d'accord avec les solutions de boost (à l'exception d'onde), s'il existe. merci

Answer 1

Si vous utilisez c99 ou c++0x il est le pragma opérateur, utilisé comme

_Pragma("argument")

ce qui est équivalent à

#pragma argument

sauf qu'il peut être utilisé dans les macros (voir la section 6.10.9 du standard c99, ou 16,9 du c++0x finale du projet de comité)

Par exemple,

#define STRINGIFY(a) #a
#define DEFINE_DELETE_OBJECT(type)                      \
    void delete_ ## type ## _(int handle);                  \
    void delete_ ## type(int handle);                   \
    _Pragma( STRINGIFY( weak delete_ ## type ## _ = delete_ ## type) )
DEFINE_DELETE_OBJECT(foo);

lors de leur mise en gcc -E donne

void delete_foo_(int handle); void delete_foo(int handle);
#pragma weak delete_foo_ = delete_foo
 ;

Answer 2

Une bonne chose que vous pouvez faire avec _Pragma("argument") est de l'utiliser pour traiter certains problèmes de compilateur comme

#ifdef _MSC_VER
#define DUMMY_PRAGMA _Pragma("argument")
#else
#define DUMMY_PRAGMA _Pragma("alt argument")
#endif

Answer 3

Non, il n'est pas portable façon de le faire. Puis de nouveau, il n'existe pas de portable façons d'utiliser la directive #pragma. De ce fait, de nombreux compilateurs C/C++ définir leurs propres méthodes pour faire pragma-comme des choses, et souvent, ils peuvent être incorporées dans les macros, mais vous avez besoin d'une autre définition de macro sur chaque compilateur. Si vous êtes prêt à aller dans cette voie, vous êtes souvent faire des choses comme ceci:

#if defined(COMPILER_GCC)
#define Weak_b
#define Weak_e __attribute__((weak))
#elif defined(COMPILER_FOO)
#define Weak_b __Is_Weak
#define Weak_e
#endif

#define DEFINE_DELETE_OBJECT(type)                      \
    Weak_b void delete_ ## type_(int handle) Weak_e;    \
    Weak_b void delete_ ## type(int handle)  Weak_e;    

Dans le cas où ses pas évident que vous voulez définir en Weak_b et Weak_e de début et de fin de bracketing de constructions, car certains compilateurs comme GCC ajouter les attributs d'un addendum à un type de signature, et certains, comme le MSC ajouter un préfixe (ou au moins, il a fait une fois, sa fait des années depuis que je l'ai utilisé MSC). Ayant bracketing contructs vous permet de définir quelque chose qui fonctionne toujours, même si vous avez à passer toute la signature d'un type dans un compilateur de construire.

Bien sûr, si vous essayez de porter ce pour un compilateur sans les attributs que vous voulez, il n'y a rien que vous pouvez faire, mais laisser les macros étendre à rien, et j'espère que votre code s'exécute toujours. En cas de purement avertissement ou de l'optimisation de pragmas, c'est probable. Dans d'autres cas, pas tellement.

Oh, et je suppose que vous auriez besoin de définir Weak_b et Weak_e que des macros qui prennent des paramètres, mais je n'étais pas prêt à lire la documentation pour savoir comment créer une faible définition juste pour cet exemple. Je laisse ça comme un exercice pour le lecteur.

Answer 4

est-il un moyen pour intégrer pragma déclaration en macro avec d'autres états?

Non, vous ne pouvez pas mettre de préprocesseur états dans préprocesseur consolidés. Vous pouvez, cependant, de le placer dans un inline fonction. Cela va à l'encontre de l' C balise.