di debug ++ modello con gdb

Question

Quando metto a punto all'interno di una funzione con template,

1. Come faccio a sapere quale modello digitare la funzione corrente sta usando?

   Ho provato p T. Dice che gdb non può stampare un tipo.

2. Come si interrompe su un tipo di modello particolare?

   Diciamo che la funzione foo<T>(...) ha 2 possibili moduli, foo<int>(...) e foo<long>(...). Come faccio a impostare un breakpoint in modo che gdb si interrompa solo sul primo che utilizza int, ma non il secondo che utilizza long?

Edit: Sarebbe bello se il punto di interruzione può essere impostato dal numero di linea. Ci sono molte buone ragioni per questo, ad es. la parte iniziale della funzione può richiede molto tempo per l'esecuzione, il luogo desidero di debug può essere all'interno di un if dichiarazione ecc

Answer 1

È possibile utilizzare ptype piuttosto che p per stampare un tipo. Con un g ++ e gdb abbastanza recente (vecchio di due anni), funzionerà.

Considerate questa fonte:

#include <iostream> 

template<typename T> 
struct S 
{ 
    S(T t) 
    { 
    std::cout << t; 
    } 
}; 

int main() 
{ 
    S<const char*> s2("hello"); 
    S<int> s1(23); 
    return 0; 
} 

Qui posso entrare nel costruttore per s2 e vedere T:

(gdb) ptype T 
type = const char * 

dare un'occhiata frame corrente:

(gdb) frame 
#0 S<char const*>::S (this=0x7fffffffe35f, t=0x400940 "hello") at q.cc:8 
8  std::cout << t; 

I può impostare un breakpoint usando il nome della funzione indicato qui:

(gdb) b S<const char *>::S 
Breakpoint 2 at 0x40087a: file q.cc, line 8. 

Answer 2

Per impostare un punto di interruzione tutte le istanze usano per:

gdb> rbreak Foo<.*> 

impostare solo un punto di interruzione su un caso noto

gdb> break Foo<int> 

È inoltre possibile utilizzare rbreak Foo<int>, ma non ha senso per usa una chiamata strega valuta le espressioni regolari ma non le dai :-)

Esempio Codice:

#include <iostream> 
#include <string> 

template < typename T> 
T Foo(T t) { return t; } 

int main() 
{ 
    std::cout << Foo<int>(1) << std::endl; 
    std::cout << Foo<std::string>("Hallo") << std::endl; 
} 

Basta compilare con le informazioni di debug:

g++ main.cpp -g -o go 

Run gdb:

gdb go 

e test:

gdb> rbreak Foo<int> 
gdb> run 
gdb> backtrace 
gdb> cont 

Come si può vedere: una sola istanza del il modello è interessato

Nella backtrace si può vedere quale istanza modello si chiama:

#0 Foo<int> (t=1) at main.cpp:5 
#1 0x0000000000400b69 in main() at main.cpp:9 

Come si può vedere è Foo<int> qui.