Pragma nella definizione macro

C'è un modo per incorporare l'istruzione pragma nella macro con altre istruzioni?

Sto cercando di ottenere qualcosa come:

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

Sono d'accordo con le soluzioni boost (salvo per wave), se ne esiste una.

Se stai usando c99 o c ++ 0x c'è l'operatore pragma, usato come

_Pragma("argument")

che è equivalente a

#pragma argument

tranne che può essere utilizzato nelle macro (vedere la sezione 6.10.9 dello standard c99 o 16.9 della bozza del comitato finale c ++ 0x)

Per esempio,

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

quando messo in gcc -Edà

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

Una cosa carina che puoi fare con _Pragma ("argomento") è usarlo per affrontare alcuni problemi del compilatore come

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

No, non esiste un modo portatile per farlo. Inoltre, non ci sono modi portatili per usare #pragma. Per questo motivo, molti compilatori C / C ++ definiscono i propri metodi per fare cose simili a pragma, e spesso possono essere incorporati nelle macro, ma è necessaria una definizione di macro diversa su ogni compilatore. Se sei disposto a seguire quella strada, spesso finisci per fare cose come questa:

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

Nel caso non sia ovvio che si desidera definire Weak_be Weak_ecome costrutti di parentesi di inizio e fine perché alcuni compilatori come GCC aggiungono gli attributi come addendum a una firma di tipo e alcuni, come MSC, lo aggiungono come prefisso (o almeno lo ha fatto una volta, sono passati anni da quando ho usato MSC). Avere i comandi di bracketing ti permette di definire qualcosa che funziona sempre, anche se devi passare l'intera firma del tipo in un costrutto del compilatore.

Ovviamente, se provi a portarlo su un compilatore senza gli attributi che desideri, non puoi fare altro che lasciare che le macro si espandano e sperare che il tuo codice funzioni ancora. In caso di pragmi puramente di avvertimento o ottimizzazione, questo è probabile. In altri casi, non così tanto.

Oh, e sospetto che avresti effettivamente bisogno di definire Weak_b e Weak_e come macro che accettano parametri, ma non ero disposto a leggere i documenti su come creare una definizione debole solo per questo esempio. Lo lascio come esercizio per il lettore.

c'è un modo per incorporare l'istruzione pragma nella macro con altre istruzioni?

No, non è possibile inserire istruzioni del preprocessore nelle istruzioni del preprocessore. Tuttavia, potresti metterlo in una inlinefunzione. Questo però sconfigge il Ctag.