CPP: evitare l'espansione delle macro di un parametro di funzione macro

Question

Quello che mi piacerebbe fare (a fini di registrazione) è qualcosa di simile:

Questo codice è stato scritto per mostrare il mio problema, codice vero e proprio è complessa e sì , ho buone ragioni per utilizzare le macro anche su C++ =)

# define LIB_SOME 1 
# define LIB_OTHER 2 

# define WHERE "at file #a, line #l, function #f: " 
// (look for syntax hightlighting error at SO xd) 
# define LOG_ERROR_SIMPLE(ptr, lib, str) ptr->log ("ERROR " str \ 
                " at library " #lib); 
# define LOG_ERROR(ptr, lib, str) LOG_ERROR_SIMPLE(ptr, lib, WHERE str) 

LOG_ERROR_SIMPLE (this, LIB_SOME, "doing something") 
LOG_ERROR (this, LIB_OTHER, "doing something else") 

LOG_ERROR_SIMPLE() scrive il in stringa del parametro lib (un nome di macro circondato da " ")

ma poi LOG_ERROR scrive il in stringa della macro già expande d ("2"). questo è previsto, dal momento che lib ha ottenuto la sua espansione prima di espandersi e chiamare LOG_ERROR_SIMPLE. ma questo non è ciò di cui ho bisogno.

Fondamentalmente la mia domanda è questa: come evitare macro l'espansione di un parametro funzione macro quando si chiama un'altra funzione macro?

C'è un trucco che uso che evita macro espansione:

LOG_ERROR(ptr, lib, str, x) LOG_ERROR_SIMPLE(ptr, x##lib, WHERE str) 

    LOG_ERROR(this, LIB_OTHER, "some error",) 

(incollare x e lib produce LIB_OTHER e questo valore viene utilizzato per chiamare LOG_ERROR_SIMPLE, la sua non macro espansa prima chiamata)

C'è un modo per ottenere questo stesso comportamento senza usare un trucco?

Answer 1

che sto facendo:

#include <cstdio> 

#define FOO 1 
#define BAR 2 

#define LOG_SIMPLE(ptr, lib, str) printf("%s\n", #lib); 
#define LOG(ptr, lib, str) LOG_SIMPLE(ptr, ##lib, str) 

int main() 
{ 
    LOG_SIMPLE(0, FOO, "some error"); 
    LOG(0, BAR, "some other error"); 
} 

che stampa:

FOO 
BAR 

Funziona con MSVC2005 ma non con gcc/g ++.

---

EDIT: per farlo funzionare con gcc/g ++ si può abusare macro variadic:

#include <stdio.h> 

#define FOO 1 
#define BAR 2 

#define LOG_SIMPLE(ptr, str, lib) printf("%s\n", #lib); 
#define LOG(ptr, str, lib, ...) LOG_SIMPLE(ptr, str, lib##__VA_ARGS__) 

int main() 
{ 
    LOG_SIMPLE(0, "some error", FOO); 
    LOG(0, "some other error", BAR); 
    LOG(0, "some other error", FOO, BAR); 
} 

Tuttavia, è la vostra disciplina di non usare la macro con troppi parametri. MSVC2005 stampa i

FOO 
BAR 
FOO2 

mentre le stampe gcc fuori

FOO 
BAR 
FOOBAR 

Answer 2

Non credo che si può. Che cosa si potrebbe fare, però, è aggiungere uno strato di macro per farlo non staccarsi al suo posto:

#define WRAP(x) x 
#define LOG_ERROR(ptr, lib, str) LOG_ERROR_SIMPLE(ptr, lib, WHERE WRAP(str)) 

Answer 3

È quasi avuto.Utilizzare

#define LOG_ERROR(ptr, lib, str) LOG_ERROR_SIMPLE(ptr, ##lib, WHERE str) 

Su gcc
LOG_ERROR(this, LIB_OTHER, "some error")
produce
this->log ("ERROR " "at file #a, line #l, function #f: " "some error" " at library " "LIB_OTHER");

Vorrei anche rimuovere il trailing ';' dal macro in modo che il codice sarà simile:
LOG_ERROR(this, LIB_OTHER, "some error");

Answer 4

Se non è necessario l'alias lib espansi (cioe '1' & '2') nelle macro cpp, si potrebbe anche usare un enum invece di valori definiti.