Simple C++ Liste Liée

J'ai beaucoup d'expérience avec les listes chaînées en Java, mais il me semble avoir confondu moi-même avec cette simple tentative en C++. J'obtiens une erreur de segmentation lors de l'exécution, qui d'après ce que je comprends a à voir avec l'affectation d'un pointeur null, mais je suis à une perte pour une solution.

Edit: Merci à tous pour les réponses. Le code fonctionne maintenant, mais en essayant d'utiliser

delete p;

à la fin de la linkedList::addNode résultats dans une erreur de segmentation lors de l'exécution. Juste curieux de savoir si quelqu'un savait pourquoi c'est?

Voici mon code mis à jour:

#include <iostream>
using namespace std;

class Node{
    public:
        int data;
    Node * next;
    Node(int x){
        data = x;
        next = NULL;
        }
    Node(int x, Node * y){
        data = x; 
        next = y;
        }
    };


class linkedList{
Node *head;
public:
    linkedList(){
        head = NULL;
        }
    void addNode(int value){
        Node *p;
        if(head == NULL)
            head = new Node (value, NULL);
        else{
            p=head;
            while(p->next !=NULL)
                p=p->next;
            p->next = new Node (value, NULL);
            }
        }
    void print(){
        Node * p;
        p = head;
        while(p != NULL){
            cout << p->data << "\n";
            p = p->next;
            }
        }
};


int main(void){
linkedList test;
test.addNode(4);
test.addNode(76);
test.addNode(12);
test.print();
return(0);
}
L'erreur de segmentation se pose parce que dès que vous supprimez un objet, vous n'êtes pas autorisé à référencer plus. Il ne fait aucun sens pour supprimer le nœud juste après que vous l'ajouter (et il y a maintenant un pointeur).
Ah ça a du sens. Merci encore.
Pourquoi êtes-vous la suppression de p dans le print()?
Mon erreur, j'ai d'abord été un peu confus au sujet de l'endroit où l'utilisation de supprimer, mais je crois que je comprends maintenant.
vous avez modifié la question d'une façon telle qu'il ne peut pas être comparé avec les réponses données

OriginalL'auteur LordByron | 2009-07-08

  1. 6

    Tout d'abord, dans linkedList::addNode méthode, vous disposez de la construction if (head = NULL), qui sera le vent attribution à head, vous voulez le == opérateur.

    Deuxième, à propos de la ligne:

    head = &(Node (value, NULL));

    Pour assez peu intuitive raisons, cela ne fonctionne pas. Vous allez obtenir une référence à un Node, mais ce nœud passe hors de portée dès que la méthode se termine, et tente de faire référence à cela conduira à une erreur de segmentation. Vous devez utiliser le new opérateur (même avec les autres analogues de la ligne):

    head = new Node(value, NULL);

    Si vous ajoutez une méthode de suppression d'un nœud, assurez-vous de delete le nœud—il ne sera pas automatiquement récupérées comme il sera en Java.

    Encadré: Penser à ce qui se fait comme ceci: lorsque vous ne Node(value, NULL), vous utilisez une variable temporaire qui est déclaré comme ceci:

    Node hiddenTempNode(value, NULL);

    Ce n'est pas allouer de l'espace pour un objet n'importe où sauf sur la pile, il est très similaire à l'allocation d'espace pour un int et un Node * sur la pile des variables distinctes. En conséquence, dès que vous quittez la méthode, l'objet disparaît et le pointeur, il va faire des choses bizarres.

    Troisième, méfiez-vous: vous souhaiterez peut-être définir next = NULL dans votre seul paramètre du constructeur, pour s'assurer qu'il possède toujours une valeur. De même pour votre constructeur par défaut.

    Quatrième: votre linkedList::print méthode est en boucle jusqu'à ce p->next est NULL et impression de la valeur de p->next; les occurrences de p->next devrait probablement être modifiée à p si vous voulez obtenir le premier et le dernier éléments.

    OriginalL'auteur John Calsbeek

  2. 3

    vous prenez l'adresse des variables sur la pile

    head = &(Node (value, NULL));

    doit être modifié pour

    head = new Node(value, NULL);

    même pour le p->suivant le code. Alors vous voulez supprimer ces nœuds dans votre destructeur.

    Comme pour l'impression d'essayer

    while(p != NULL)
{
   cout << p->data << "\n";
   p = p->next;
}

    OriginalL'auteur jcopenha

  3. 2

    Vous êtes allocation d'espace pour les nœuds sur la pile et en saisissant son adresse, ce qui disparaîtront dès que le bloc se termine et, par conséquent, l'adresse sera invalidée. Vous devez allouer des nœuds à l'aide de new opérateur sur le tas plutôt:

    Node* node = new Node(value, NULL);

    Vous devez libérer tout ce que vous allouer sur le tas dès que vous n'en avez pas besoin pour empêcher la fuite de mémoire:

    delete node;

    OriginalL'auteur Mehrdad Afshari

  4. 2

    Pour commencer

    if(head = NULL)

    est une mission, pas une case pour l'égalité. Changer de

    if(head == NULL)

    Deuxièmement,

    head = &(Node (value, NULL));

    Ne fait pas de sens* remplacez

    head = new Node (value, NULL);

    *ceci crée en fait un objet temporaire, vous donne l'adresse, puis détruit que l'objet nouvellement créé.

    Troisièmement,

    Node(int x) { data = x; }

    Laisser next sans valeur, modifiez cette ligne pour

    Node(int x) { data = x; next = NULL; }
    Oh mon ce un oubli flagrant :(, mais je suis maintenant confronté à une impression répétée de 134514880
    Vérifiez tous les autres réponses, puis d'éditer votre premier post pour montrer votre code actuel.

    OriginalL'auteur eduffy

  5. 1

    Vous n'êtes pas de l'allocation de mémoire.Vous devez utiliser les nouvelles à attribuer.

    Encore une erreur dans le if(tete = NULL) , il devrait l'être, si(tete == NULL)

    void addNode(int value){
            Node *p;
            if(head == NULL)
                    head =  new Node (value, NULL);
            else{
                    p=head;
                    while(p->next !=NULL)
                            p=p->next;
                    p->next = new Node (value, NULL);
                    }
            }

    OriginalL'auteur anand

  6. 1

    Je voudrais ajouter deux questions qui n'ont pas été mentionnés, encore:

    • lorsque vous les "nouveaux" objets, vous devez 'supprimer' à un certain point.
    • tous les trois de votre constructeur doit initialiser les variables de membre.

    OriginalL'auteur Ralph

  7. 1

    Votre instruction delete n'est pas en train de faire tout le nettoyage. Par le temps que vous l'appelez p==null. Si vous voulez nettoyage de la liste, vous aurez besoin de mettre en œuvre une méthode distincte pour parcourir et supprimer à chaque nœud.

    Quelque chose comme ceci:

    void ClearList ()
{
    Node * c = head;
    Node * n;

    while (c != NULL)
    {
        n = c->next;
        delete c;
        c = n;
    }
}
    Merci, donc il suffit de réglage de la tête = NULL laisser tous les autres nœuds d'occupation de la mémoire alors?
    Qui est correct.

    OriginalL'auteur csj

  8. 0

    Le code fonctionne maintenant, mais en essayant de
    utilisation

    delete p;

    à la fin de la linkedList::addNode
    résultats dans un segmentation fault à
    moment de l'exécution. Juste curieux de savoir si quelqu'un savait
    pourquoi c'est?

    Bien c'est un problème parce que le but de l'ajout d'un nœud a pour fonction d'allouer dynamiquement un nouveau nœud à la fin de la LinkedList. Si vous faites cela correctement, maintenant en mettant 'delete p;' vous êtes en train de supprimer le nœud nouvellement ajouté (j'imagine que vous n'avez pas vraiment envie). Cependant, pour répondre à votre question qui est pourquoi cela provoque une erreur de segmentation:

    Vous ajoutez un nœud, vous dites à la tête au point de ce nouveau nœud. Maintenant, vous supprimer ce nouveau nœud sans en parler à tête qu'il devrait une fois de plus souligner la valeur NULL. Ainsi, la prochaine fois vous ajoutez un nœud, ou essayez d'imprimer votre liste, il sera immédiatement essayer de regarder ce que la tête de vers, qui est en fait libéré (supprimé) de mémoire, kaboom?

    Le bon (ou au moins correct) utilisation de supprimer de votre liste est dans un destructeur, n'oubliez pas en C++ on a toujours envie de nettoyer la mémoire dynamique que nous avons alloué, votre destructeur pourrait ressembler à:

    ~linkedList()
{
    Node* p = head;
    while ( p!=NULL )
    {
        Node* nextNode = p->next;
        delete p;
        p = nextNode;
    }
}

    À l'aide d'un destructeur comme cela, vous pouvez garantir que votre linkedList seront nettoyés de façon appropriée lorsqu'elle est hors de portée, ou est supprimé.

    OriginalL'auteur DeusAduro

  9. -2

    Solution: Ne pas mettre en place votre propre liste liée. Utilisez celui fourni par la bibliothèque standard.

    Je pense que c'est un bon exercice pour mettre en œuvre un vous-même au moins une couple de fois.
    Dans certaines langues, oui. En C++, qu'est ce qu'il va vous enseigner? SI elle semble fonctionner, mais contient toujours un certain nombre de bugs que vous n'aviez pas repéré, qui a fait de vous un meilleur programmeur? L'écriture de code qui semble fonctionner en C++, c'est facile. Écrire du code qui est en fait corriger est très dur. Sauf si vous avez une certaine façon de s'assurer que vous êtes la réalisation de ce dernier, cet exercice ne vais pas vous apprendre quoi que ce soit.

    OriginalL'auteur jalf