C++ - verknüpfte Liste wird nicht ausgeführt, wie ich erwartet habe (Smart Pointer)

Question

#include <iostream> 
#include <memory> 

using namespace std; 


class Node 
{ 

//Private variables. 
private: 
    std::unique_ptr<Node> next; //Next node. 
    std::unique_ptr<Node> prev; //Previous node. 


    //Int value. 
    int value; 



//Public variables. 
public: 

    //Constructor. 
    Node(int v) 
    :next(nullptr), prev(nullptr), value(v) 
    { 
    } 


    //Set next node. 
    void set_next(std::unique_ptr<Node> new_node) 
    { 
     next = std::move(new_node); 
    } 


    //Set previous node. 
    void set_prev(std::unique_ptr<Node> new_node) 
    { 
     prev = std::move(new_node); 
    } 


    //Set value. 
    void set_value(int v) 
    { 
     value = v; 
    } 


    //Get next node. 
    std::unique_ptr<Node> get_next() 
    { 
     return std::move(next); 
    } 


    //Get previous node. 
    std::unique_ptr<Node> get_prev() 
    { 
     return std::move(prev); 
    } 


    //Get value. 
    int get_value() 
    { 
     return value; 
    } 



}; 


class LinkedList 
{ 

//Private variables. 
private: 
    std::unique_ptr<Node> head; 
    std::unique_ptr<Node> tail; 



//Public variables. 
public: 

    //Constructor. 
    LinkedList() 
    :head(nullptr), tail(nullptr) 
    { 
    } 


    //Append a item to the list. 
    void append(int v) 
    { 

     //Creating a new node. 
     std::unique_ptr<Node> new_node(new Node(v)); 


     //If this is the very first node. 
     if (head == nullptr || tail == nullptr) 
      { 
       head = std::move(new_node); 
       tail = std::move(new_node); 
      } 



     //Append. 
     else 
      { 
       tail -> set_next(std::move(new_node)); //Linking the new node. 
       new_node -> set_prev(std::move(tail)); //Set the previous. 
       tail = std::move(new_node);    //Update the tail. 
      } 

    } 


    //Print all the elements. 
    void print() 
    { 

     //Starting node. 
     std::unique_ptr<Node>curr = std::move(head); 


     //While Loop. 
     while(curr != nullptr) 
      { 
       cout << curr -> get_value() << endl; 
       curr = std::move(curr -> get_next()); 
      } 
    } 

}; 


int main() 
{ 
LinkedList myList; 

myList.append(1); 
myList.append(2); 
myList.append(3); 
myList.append(4); 

myList.print(); 

return 0; 
} 

Ich sollte für Ausgabe 1,2,3,4 sehen, aber stattdessen sehe ich nur 4! Ich habe das Debuggen und ich fand heraus, die folgende Anweisung läuft 4mal:

  //If this is the very first node. 
     if (head == nullptr || tail == nullptr) 
      { 
       head = std::move(new_node); 
       tail = std::move(new_node); 
      } 

Aber warum 4-mal ausgeführt wird? Das erste Mal, Kopf und Schwanz wird null sein, aber danach werden sie irgendwo Punkt so diese Aussage sollte nie laufen wieder.

Ich bin neu mit Smart-Pointer so denke ich, gibt es, wo ich fehlt.

Answer 1

Eine grundlegende Eigenschaft eines std::unique_ptr ist, dass nur ein std::unique_ptr einen gegebenen Zeiger zur gleichen Zeit besitzen kann. Dies ist genau das, worum es beim "einzigartigen" Teil geht.

std::unique_ptr<Node> new_node(new Node(v)); 

Ok. So weit, ist es gut.

head = std::move(new_node); 
    tail = std::move(new_node); 

Und das ist dein Problem. Sie versuchen, dieselbe std::unique_ptr in zwei andere zu verschieben. Das wird nicht funktionieren. Nur einer von ihnen kann einen Zeiger besitzen.

Ersetzen Sie alle Ihre std::unique_ptr s durch std::shared_ptr s.