c++ - 带有 unique_ptr 的通用单链表，MS visual studio C++ 中的未知错误

Question

我发了一个帖子，将对此 here 进行扩展.我知道对什么时候使用 unique_ptr 什么时候不使用有更好的理解。虽然，强调一点，我仍然遇到一些错误，这些错误很可能与对 unique_ptr 的理解不够好有关。

这是我遇到的错误:

1>------ Build started: Project: LinkedList, Configuration: Debug Win32 ------
1>main.cpp
1>c:\dev\linkedlist\linkedlist\singlelinkedlist.h(166): error C2679: binary '=': no operator found which takes a right-hand operand of type 'SingleLinkedList<int>::Node *' (or there is no acceptable conversion)
1>c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\memory(2309): note: could be 'std::unique_ptr<SingleLinkedList<int>::Node,std::default_delete<_Ty>> &std::unique_ptr<_Ty,std::default_delete<_Ty>>::operator =(const std::unique_ptr<_Ty,std::default_delete<_Ty>> &)'
1>        with
1>        [
1>            _Ty=SingleLinkedList<int>::Node
1>        ]
1>c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\memory(2247): note: or       'std::unique_ptr<SingleLinkedList<int>::Node,std::default_delete<_Ty>> &std::unique_ptr<_Ty,std::default_delete<_Ty>>::operator =(std::unique_ptr<_Ty,std::default_delete<_Ty>> &&) noexcept'
1>        with
1>        [
1>            _Ty=SingleLinkedList<int>::Node
1>        ]
1>c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\memory(2173): note: or       'std::unique_ptr<SingleLinkedList<int>::Node,std::default_delete<_Ty>> &std::unique_ptr<_Ty,std::default_delete<_Ty>>::operator =(std::nullptr_t) noexcept'
1>        with
1>        [
1>            _Ty=SingleLinkedList<int>::Node
1>        ]
1>c:\dev\linkedlist\linkedlist\singlelinkedlist.h(166): note: while trying to match the argument list '(std::unique_ptr<SingleLinkedList<int>::Node,std::default_delete<_Ty>>, SingleLinkedList<int>::Node *)'
1>        with
1>        [
1>            _Ty=SingleLinkedList<int>::Node
1>        ]
1>c:\dev\linkedlist\linkedlist\singlelinkedlist.h(163): note: while compiling class template member function 'void SingleLinkedList<int>::deleteHead(void)'
1>c:\dev\linkedlist\linkedlist\singlelinkedlist.h(85): note: see reference to function template instantiation 'void SingleLinkedList<int>::deleteHead(void)' being compiled
1>c:\dev\linkedlist\linkedlist\singlelinkedlist.h(83): note: while compiling class template member function 'SingleLinkedList<int>::~SingleLinkedList(void)'
1>cI made a post that will be an extention to this [enter link description here][1]:\dev\linkedlist\linkedlist\main.cpp(23): note: see reference to function template instantiation 'SingleLinkedList<int>::~SingleLinkedList(void)' being compiled
1>c:\dev\linkedlist\linkedlist\main.cpp(23): note: see reference to class template instantiation 'SingleLinkedList<int>' being compiled
1>Done building project "LinkedList.vcxproj" -- FAILED.
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

我应该再次提到我是 MS visual studio C++ 和 unique_ptr 的新手。我最初只使用新指针编写此实现，但有人建议我使用 unique_ptr 重写它。

这是我的头文件:

#ifndef SingleLinkedList_h
#define SingleLinkedList_h

#include <iostream>

template <class T>
class SingleLinkedList {
private:

    struct Node {
        T data;
        std::unique_ptr<Node> next = nullptr;
        Node(T x) : data(x), next(nullptr) {}
    };
    std::unique_ptr<Node> head = nullptr;
    std::unique_ptr<Node> tail = nullptr;

    // This function is for the overloaded operator << 
    void display(std::ostream &str) const {
        for (Node* loop = head.get(); loop != nullptr; loop = loop->next.get()) {
            str << loop->data << "\t";
        }
        str << "\n";
    }

public:
    // Constructors
    SingleLinkedList() = default;                                           // empty constructor 
    SingleLinkedList(SingleLinkedList const &source);                       // copy constructor

    // Rule of 5
    SingleLinkedList(SingleLinkedList &&move) noexcept;                     // move constructor
    SingleLinkedList& operator=(SingleLinkedList &&move) noexcept;          // move assignment operator
    ~SingleLinkedList();                                    

    // Overload operators
    SingleLinkedList& operator=(SingleLinkedList const &rhs);
    friend std::ostream& operator<<(std::ostream &str, SingleLinkedList &data) {
        data.display(str);
        return str;
    }

    // Memeber functions
    void swap(SingleLinkedList &other) noexcept;
    bool empty() const { return head.get() == nullptr; }
    void push(const T &theData);                            
    void push(T &&theData);
    void display() const;
    void insertHead(const T &theData);
    void insertTail(const T &theData);
    void insertPosition(int pos, const T &theData);
    void deleteHead();
    void deleteTail();
    void deletePosition(int pos);
    bool search(const T &x);
};

template <class T>
SingleLinkedList<T>::SingleLinkedList(SingleLinkedList<T> const &source) {
    for(Node* loop = source->head.get(); loop != nullptr; loop = loop->next.get()) {
        push(loop->data);
    }
}

template <class T>
SingleLinkedList<T>::SingleLinkedList(SingleLinkedList<T>&& move) noexcept {
    move.swap(*this);
}

template <class T>
SingleLinkedList<T>& SingleLinkedList<T>::operator=(SingleLinkedList<T> &&move) noexcept {
    move.swap(*this);
    return *this;
}

template <class T>
SingleLinkedList<T>::~SingleLinkedList() {
    while (head != nullptr) {
        deleteHead();
    }
}

template <class T>
SingleLinkedList<T>& SingleLinkedList<T>::operator=(SingleLinkedList const &rhs) {
    SingleLinkedList copy{ rhs };
    swap(copy);
    return *this;
}

template <class T>
void SingleLinkedList<T>::swap(SingleLinkedList &other) noexcept {
    using std::swap;
    swap(head, other.head);
    swap(tail, other.tail);
}

template <class T>
void SingleLinkedList<T>::push(const T &theData) {
    std::unique_ptr<Node> newNode = std::make_unique<Node>(theData);

    if (head == nullptr) {
        head = std::move(newNode);
        tail = head.get();
    }

    else {
        tail->next = std::move(newNode);
        tail = tail->next.get();
    }
}

//template <class T>
//void SingleLinkedList<T>::push(T &&theData) {
//  std::unique_ptr<Node> newNode = std::make_unique<Node>(std::move(theData));
//
//  if (head == nullptr) {
//      head = std::move(newNode);
//      tail = head.get();
//  }
//
//  else {
//      tail->next = std::move(newNode);
//      tail = tail->next.get();
//  }
//}


template <class T>
void SingleLinkedList<T>::display() const {
    Node* newNode = head.get();
    while (newNode != nullptr) {
        std::cout << newNode->data << "\t";
        newNode = newNode->next;
    }
}

template <class T>
void SingleLinkedList<T>::insertHead(const T &theData) {
    std::unique_ptr<Node> newNode = std::make_unique<Node>(theData);
    newNode->next = head.get();
    head = newNode;
}

template <class T>
void SingleLinkedList<T>::insertTail(const T &theData) {
    std::unique_ptr<Node> newNode = std::make_unique<Node>(theData);
    tail->next = newNode;
    tail = newNode;
}

template <class T>
void SingleLinkedList<T>::insertPosition(int pos, const T &theData) {

}

template <class T>
void SingleLinkedList<T>::deleteHead() {
    Node* old = head.get();
    delete old;
    head = head->next.get();
}

template <class T>
void SingleLinkedList<T>::deleteTail() {

}

template <class T>
void SingleLinkedList<T>::deletePosition(int pos) {

}

template <class T>
bool SingleLinkedList<T>::search(const T &x) {

}




#endif /* SingleLinkedList_h*/

这是 main.cpp 文件:

#include <algorithm>
#include <cassert>
#include <iostream>
#include <ostream>
#include <iosfwd>
#include "SingleLinkedList.h"


int main(int argc, const char * argv[]) {


    ///////////////////////////////////////////////////////////////////////
    ///////////////////////////// Single Linked List //////////////////////
    ///////////////////////////////////////////////////////////////////////
    SingleLinkedList<int> obj;
    obj.push(2);
    obj.push(4);
    obj.push(6);
    obj.push(8);
    obj.push(10);
    std::cout<<"\n--------------------------------------------------\n";
    std::cout<<"---------------displaying all nodes---------------";
    std::cout<<"\n--------------------------------------------------\n";
    std::cout << obj << std::endl;

    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"-----------------Inserting At End-----------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.insertTail(20);
    //    std::cout << obj << std::endl;
    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"----------------Inserting At Start----------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.insertHead(50);
    //    std::cout << obj << std::endl;
    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"-------------Inserting At Particular--------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.insertPosition(5,60);
    //    std::cout << obj << std::endl;
    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"----------------Deleting At Start-----------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.deleteHead();
    //    std::cout << obj << std::endl;
    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"----------------Deleting At End-----------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.deleteTail();
    //    std::cout << obj << std::endl;
    //
    //
    //    std::cout<<"\n--------------------------------------------------\n";
    //    std::cout<<"--------------Deleting At Particular--------------";
    //    std::cout<<"\n--------------------------------------------------\n";
    //    obj.deletePosition(4);
    //    std::cout << obj << std::endl;
    //    std::cout << std::endl;
    //
    //    obj.search(8) ? printf("Yes"):printf("No");







    std::cin.get();
}

Answer 1

链表使用唯一指针是没有意义的。出于练习目的，您可以使用原始指针。出于实用目的，请使用 std::list 或其他容器。

它没有意义的原因是你的尾部可能指向同一个节点和另一个节点的下一个节点。那么它就不是唯一的了。