如何实现两个成员函数（push_front 和析构函数）？

Question

我正在尝试实现两个成员函数，即push_front 和destructor。我已经编写了push_front 函数的代码。但我似乎，我在任何地方都做错了。我该如何解决这个问题？如何在Linked-List前面正确插入节点？

template <typename T>
class Node {
public:
    Node():next_p_{nullptr} {}
    Node(T v, Node* n):data_{v}, next_p_{n} {}
   ~Node() {};

    void     setData( T &v ) { data_ = v; }
    const T &getData() const { return data_; }
    void  setNext( Node *n ) { next_p_ = n; }
    Node *getNext() const { return next_p_; }

private:
  T data_;
  Node *next_p_;
};

template <typename T>
class LinkedList {
private:
  Node<T> *head_ptr_;
public:
    LinkedList():head_ptr_{nullptr} {}
   ~LinkedList() {
    }

    // Insert at the front of the linked list (UPDATED)
    void push_front( T v ){
        Node *new_node = new Node;
        new_node->setNext(*head_ptr_) = v;
        new_node->next_p_ = this->head_ptr_;
        this->head_ptr_ = new_node;
    }
};

Answer 1

第一个Node 构造函数获取值和下一个指针，使用它一步创建新节点。

在将head_ptr_ 用作下一个指针时，不应取消引用它。它已经是Node*，这是head_ptr_ 的正确类型。

    void push_front( T v ){
        Node *new_node = new Node(v, head_ptr_);
        this->head_ptr_ = new_node;
    }

Answer 2

我还建议不要处理手动内存管理，而是使用智能指针来简化您的生活。

使用std::unique_ptr，您无需处理从空闲存储中回收分配的内存。

这种方法的一个警告是您无法复制List，但通常这就是您想要的。

template<typename T>
class List { 
    struct Node { 
        Node( T value ) noexcept
            : data{ std::move_if_noexcept( value ) }
        { }

        T data;
        std::unique_ptr<Node> next{ nullptr };
    };
public:
    auto push_front( T value ) -> void {
        auto node{ std::make_unique<Node>( std::move_if_noexcept( value ) ) };
        std::swap( node->next, head_ );
        std::swap( head_, node );
    }

    ~List()
    {
        while (head_) {
            std::unique_ptr<Node> tmp(std::move(head_));
            head_ = std::move(tmp->next);
        }
    }
private:
    std::unique_ptr<Node> head_{ nullptr };
};