C ++ - Erreur GDB Question

Question

C ++ - Erreur GDB Question

voix

1

Je travaille sur un arbre de recherche binaire en C ++. Je reçois les erreurs suivantes signalées après l'exécution gdb (je reçois une erreur de segmentation) sur mon programme:

#0  0x08049058 in searchTree::tree_node<int>::getLeft (this=0x0) at bst.hxx:75
#1  0x08048ed8 in searchTree::bst_iter<int>::operator++ (this=0xbffff4b4) at bst.hxx:586
#2  0x08048a72 in main () at projectmain.cxx:29

Le # 0 erreur fait référence à ma fonction getLeft (), qui est la suivante:

    template <typename T>
    inline tree_node<T>* tree_node<T>::getLeft() const
    {
        return tree_node<T>::left_; //note that left_ is of type tree_node<T>*
    }

Le # 1 erreur fait référence à mon opérateur ++ défini dans mon itérateurs, qui est la suivante:

        bst_iter<T>& operator++()
        { //note that s is a stack of tree_node<T>*
            tree_node<T> *p = pos_->getRight();
            s.push(p);
            for(p=p->getLeft(); p!=NULL; p=p->getLeft())
            {
                s.push(p);
            }
            pos_ = s.top();
            s.pop();
            return *this;
        }

Le # 2 erreur fait référence à mon programme principal, dans lequel je suis, y compris le fichier qui contient mes définitions pour tree_node, BinaryTree, bst_iter et bst_citer (qui n'existe pas à ce stade, donc pas un problème).

                            bst_iter<int> i = treeTime.begin(); //treeTime is our tree
            bst_iter<int> iEnd = treeTime.end();
                            for(; i != iEnd ;++i) //crash
            {
                cout<<*i<< ;
            }

        template <typename T>
        inline bst_iter<T> binaryTree<T>::begin()
         {

             return bst_iter<T>(root_);
         }

        template <typename T>
        inline bst_iter<T> binaryTree<T>::end()
         {
            return bst_iter<T>(0);
         }

Je ne suis pas tout à fait sûr ce qui cause l'erreur. Je crois que ++ () tente d'accéder à une zone qui n'a pas été défini, mais je ne suis pas vraiment sûr pourquoi il fait ça, ou comment arrêter ... J'ai essayé de retenir le code, comme le code est près de 800 lignes, mais si plus d'information est nécessaire, laissez-moi savoir ...

c++iterator binary-search-tree

Créé 05/04/2011 à 02:32
source utilisateur muttley91

Dans d'autres langues...

3 réponses

nsanders · Answer 1 · 2011-04-05 02:36

voix

1

Comment êtes-vous initialisez votre boucle iterator i? Si elle est valide pour commencer, alors cela expliquerait les choses.

Créé 05/04/2011 à 02:36
source utilisateur nsanders

xDD · Answer 2 · 2011-04-05 02:46

voix

0

Cela pourrait se produire si pos _-> getRight () renvoie un pointeur NULL.

Puisque vous appelez getLeft sur le résultat sans vérifier pour null, vous vous retrouvez avec un pointeur ce qui est nul.

Créé 05/04/2011 à 02:46
source utilisateur xDD

Arvid · Answer 3 · 2011-04-05 02:46

Comme vous pouvez le voir dans le retraçage gdb, vous finissez par appeler getLeft()un pointeur NULL. à- dire son ce pointeur est NULL.

Dans votre boucle à l' intérieur de la operator++, vous appelez getLeft()le psans d' abord vérifier si elle est NULL. à savoir si getRight()retourne NULL, vous brisez.

Vous voulez sans doute faire quelque chose comme ceci:

bst_iter<T>& operator++()
    { //note that s is a stack of tree_node<T>*
        tree_node<T> *p = pos_->getRight();
        if (p == NULL) p = pos_;
        else s.push(p);
        for(p=p->getLeft(); p!=NULL; p=p->getLeft())
        {
            s.push(p);
        }
        // TODO: what if s is empty?
        pos_ = s.top();
        s.pop();
        return *this;
    }

Ce n'est pas une solution complète bien. Cela dépend un peu de ce que votre end()état de l'itérateur est censé être.

Cependant, il semble comme il y a des plus efficaces et des moyens plus intuitifs de mise en œuvre operator++. STL par exemple , vous permet de supprimer des entrées dans un arbre et que invalidantes itérateurs pointant vers ce nœud. Dans votre cas, tous les itérateurs devraient être invalidée.