Come si imita la versione Microsoft di __FUNCTION__ utilizzando gcc?

Question

Quando utilizzo la macro/variabile __FUNCTION__ per stampare le informazioni di debug, sembra esserci una differenza in ciò che viene emesso quando si utilizza il compilatore e il ccc Microsoft C++. Ad esempio, utilizzando il seguente codice banale:

class Foo 
{ 
    public: 
     void Bar(int a, int b, int c) 
     { 
      printf ("__FUNCTION__ = %s\n", __FUNCTION__); 
     } 
}; 

int main (void) 
{ 
    Foo MyFoo; 

    MyFoo.Bar(); 

    return 0; 
} 

Utilizzando Visual C++ Microsoft, ottengo

__FUNCTION__ = Foo::Bar 

mentre quando la compilazione utilizzando gcc (in questo caso su Mac), ottengo

__FUNCTION__ = Bar 

Il secondo esempio non è l'ideale, perché molto spesso hanno diverse classi con, diciamo, Init() e Uninit() metodi e in un output di debug rintracciare la sua virtua impossibile dire quale di questi è stato chiamato poiché il nome della classe mancherà. Ora, so che è possibile utilizzare il __PRETTY_FUNCTION__ al posto di __FUNCTION__ per ottenere qualcosa di simile

__PRETTY_FUNCTION__ = void Foo::Bar(int, int, int) 

che va bene, ma è un po 'troppo prolisso per quello che mi serve e diventa un po' lungo per le funzioni con un sacco di parametri .

Quindi la mia domanda è (finalmente), c'è un modo per ottenere il risultato a guardare come semplicemente Foo::Bar usando gcc, come nell'esempio di cui sopra?

Answer 1

Se lo si utilizza per la traccia, è sempre possibile utilizzare typeid(T).name() e compilare solo condizionatamente per piattaforma. Certamente non conveniente come la macro, ma potrebbe funzionare.

vagamente simile a __CLASS__ macro in C++

Answer 2

Il nome-funzione sancita dallo standard è definito come segue:

static const char __func__[] = "function-name "; 

Esempio:

#include <iostream> 

namespace meh { 
    void foobar() { std::cout << __func__ << std::endl; } 
}; 

struct Frob { 
    void foobar() { std::cout << __func__ << std::endl; } 
    static void barfoo() { std::cout << __func__ << std::endl; } 
}; 

int main() { 
    std::cout << __func__ << std::endl; 
    meh::foobar(); 
    Frob().foobar(); 
    Frob::barfoo(); 
} 

Tuttavia, output con g ++:

main 
foobar 
foobar 
barfoo 

Tuttavia, cioè Comportamento C++ valido:

§ 8.4.1, 8: La variabile predefinita funzione locale __func__ è definita come una definizione della forma static const char __func__[] = "function-name "; era stato fornito, dove nome-funzione è una stringa definito dall'implementazione. Non è specificato se tale variabile abbia un indirizzo distinto da quello di qualsiasi altro oggetto nel programma

I.e., non ci si può fidare del suo valore. Se si desidera utilizzare estensioni non portatili, dare un'occhiata a una domanda simile: What's the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?.