Examiner boost shared_ptr avec gdb

Voici mon code source:

#include <iostream>
#include <boost/shared_ptr.hpp>

class MyClass
{
    public:
        MyClass()
        {
            i=10;
        }
    private:
        int i;
};


int main(int argc, const char *argv[])
{
    boost::shared_ptr <MyClass> obj(new MyClass());
    return 0;
}

Je veux examiner obj dans gdb, et afficher la valeur de la variable de membre de que je.

C'est ce que j'obtiens avec la normale d'impression:

29          boost::shared_ptr <MyClass> obj(new MyClass());
(gdb) n
30          return 0;
(gdb) p obj
$1 = {px = 0x602010, pn = {pi_ = 0x602030}}

J'ai essayé l'astuce mentionnée dans ce lien , mais ne fonctionne pas.

(gdb) call (obj.get())->print()
Cannot evaluate function -- may be inlined

Est-il un autre moyen? gdb version 7.0.1.

Un autre bon vieil ami est clair printf 🙂
Anand Rathi..., oui, mais je voulais juste savoir si c'est possible avec gdb.

InformationsquelleAutor m.divya.mohan | 2013-07-23

boost c++gdb shared-ptr

30

L'ai eu.!
```
(gdb) set print pretty
(gdb) p obj
$5 = {
  px = 0x602010,
  pn = {
    pi_ = 0x602030
  }
}
(gdb) p obj.px
$6 = (MyClass *) 0x602010



(gdb) p *(obj.px)
$7 = {
  i = 10
}
```
- C'est la chose la plus utile que j'ai vu tous les jours!!! Merci une tonne. Je ne savais pas que je pouvais déréférencer le pointeur de cette façon. 🙂
- Cela ne fonctionne pas pour moi. "p obj" donne $2 = std::shared_ptr (count 2, weak 1) 0x639268, et "p obj.px" donne There is no member or method named px. J'ai aussi essayé "p *obj", mais pas de joie: Could not find operator*.
InformationsquelleAutor m.divya.mohan

Essayez ceci:

d'impression (*obj.px).je

code complet est ci-dessous:

 (gdb) list 1,23
1       #include <iostream>
2       #include <boost/shared_ptr.hpp>
3       #include <string>
4
5       class MyClass
6       {
7           public:
8               MyClass()
9                   : name("Testing")
10              {
11                  i=10;
12              }
13          private:
14              int i;
15              std::string name;
16      };
17
18
19      int main(int argc, const char *argv[])
20      {
21          boost::shared_ptr <MyClass> obj(new MyClass());
22          return 0;
23      }
(gdb) p obj
$9 = {px = 0x602010, pn = {pi_ = 0x602060}}
(gdb) p (*obj.px).i
$10 = 10
(gdb) p (*obj.px).name
$11 = {static npos = 18446744073709551615,
  _M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>},
    _M_p = 0x602048 "Testing"}}

InformationsquelleAutor Ganesh M

0

Cela va être dur de répondre. GDB 7.x ajouté un script Python de soutien. Il y a quelques ressources sur le web. Plutôt que de faire une mauvaise tentative de conseiller sur quelque chose que je n'ai pas de première expérience, je vais vous référer à un passé post:

C++ GDB Python Jolie Impression Tutoriel?

InformationsquelleAutor dans3itz
0

Lors de la compilation d'utilisation -ggdb option et voir si cela fonctionne

http://sourceware.org/gdb/onlinedocs/gdb/Inline-Functions.html

Inline est une optimisation qui insère une copie de la fonction du corps directement à chaque site d'appel, au lieu de sauter à une salle de routine. gdb affiche inline fonctions des fonctions inline. Ils apparaissent dans backtraces. Vous pouvez voir leurs arguments et les variables locales, d'étape en étape, les sauter à la prochaine, et échapper à la fin. Vous pouvez vérifier si une fonction a été incorporé en utilisant les informations de trame de commande.

Pour gdb pour soutenir les fonctions inline, le compilateur doit enregistrer l'information sur l'in-lining dans les informations de débogage — gcc en utilisant le nain 2 format fait cela, et plusieurs autres compilateurs de le faire aussi. gdb prend uniquement en charge les fonctions inline lors de l'utilisation de nain 2. Versions de gcc 4.1 avant n'émettent pas de deux attributs obligatoires (‘DW_AT_call_file " et " DW_AT_call_line’); gdb n'affiche pas de fonction inline appels avec les anciennes versions de gcc. Il affiche plutôt les arguments et les variables locales des fonctions inline comme des variables locales en l'appelant.

Le corps d'une fonction inline est directement intégré à son site d'appel; contrairement à un non-fonction inline, il n'y a pas d'instructions consacrée à l'appel. gdb continue à prétendre que le site d'appel et le début de la fonction inline sont des instructions différentes. L'intensification de l'appel du site indique le site d'appel, puis marcher à nouveau montre la première ligne de la fonction inline, même en l'absence d'autres instructions sont exécutées.

Ce fait au niveau de la source de débogage beaucoup plus claire; vous pouvez voir à la fois le contexte de l'appel, puis l'effet de l'appel. Seulement marcher par une seule instruction à l'aide de stepi ou nexti ne le fait pas; seule instruction suit toujours les inline corps.

Il y a quelques façons que gdb ne prétend pas que inline appels de fonction sont les mêmes que pour les appels normaux:

Définition de points d'arrêt sur le site d'appel d'une fonction inline ne peut pas fonctionner, parce que l'appel du site ne contiennent pas de code. gdb incorrecte peut déplacer le point d'arrêt à la ligne suivante de la fonction englobante, après l'appel. Cette limitation sera supprimée dans une future version de gdb; jusqu'alors, définissez un point d'arrêt sur une ancienne ligne ou à l'intérieur de la fonction inline à la place.
gdb ne peut pas localiser la valeur de retour de inline appels après l'utilisation de la finale de la commande. Cette restriction est généré par le compilateur des informations de débogage; après avoir fini, vous pouvez pas à la ligne suivante et l'impression d'une variable où votre programme stocké la valeur de retour.

InformationsquelleAutor Anand Rathi

Vous devez vous connecter pour publier un commentaire.