Question

受CppCon2016上Herb Sutter的谈话启发，which can be found in this link.
我决定使用智能指针实现视频中所示的双向链接列表。
以下实现几乎与remove（）方法中的一行代码分开工作。
我调试了这段代码，并且移除后，上一个节点未更新为null（应该是头节点）。
好像智能指针之间的所有权转移是错误的。下面是头文件和测试main（）的代码：

LinkedList.h

#ifndef LINKEDLIST_H
#define LINKEDLIST_H

#include <iostream>
#include <memory>
#include <initializer_list>

namespace DLL {
    template <typename T> class LinkedList{
        private:
            struct ListNode{
                std::unique_ptr<ListNode> next; //2 uniq_ptr can't point to one another.
                ListNode* prev = nullptr; //weakptr needs to be cast back to a shared_ptr to check its state.
                T data{}; //Initialize empty;

            ListNode(const T& element){
                this->data = element;
            }
        };
    public:
        std::unique_ptr<ListNode> head;
        ListNode* tail = nullptr;

        LinkedList(){}
        ~LinkedList(){}

        void append(const T& element){
            ListNode* curr = nullptr;
            if (head.get() == nullptr){ //If list is empty.
                head = std::make_unique<ListNode>(element);
            }
            else if(head.get() -> next.get() == nullptr){ //If list has one element
                 head.get() -> next = std::make_unique<ListNode>(element);
                 curr = head.get() -> next.get(); //Sets raw pointer to the first element.
                 curr -> prev = head.get();
                 tail = curr;
            }
            else{
                tail -> next = std::make_unique<ListNode>(element);
                curr = tail -> next.get(); //Sets raw pointer to the last element.
                curr -> prev = tail;
                tail = curr;// The new last element is the tail.
            }
        }

        int remove(const T& element){
            ListNode* curr = nullptr;
            if (head.get() == nullptr){ //If list is empty.
                return -1; //Error: Can't remove from empty list.
            }
            //List has one or more elements.
            curr = head.get();
            while(curr != nullptr){
                if(curr -> data == element){ //Found element
                    if(curr -> prev == nullptr){ //is head
                    //head.reset(head.get()->next.get()); Doesn't work
                    //Line below doesn't work too
                    head = std::move(curr->next); //Head now points to the next element
                    //New head's previous element doesn't point to nothing, as it should.
                    }
                    else if(curr -> next.get() == nullptr){ //is tail
                        tail = curr -> prev; //Reference the previous element
                        tail -> next.release(); //Release the old tail element
                        if(head.get() == tail){
                            tail = nullptr; //tail and head should not be the same.
                        } //List contains one element
                    }
                    else{//is intermediate
                        //The next node should point to the previous one
                        curr -> next -> prev = curr -> prev;
                        curr -> prev -> next = std::move(curr -> next);
                        //The prev node now points to the next one of current.
                    }
                    return 1; //Element found in list
                }
                curr = curr -> next.get(); //Traverse the next element
            }
            return 0; //Element not found in list
        }

        void print() {
            ListNode* curr = head.get(); //Start from the start of the list.
            std::cout << "[ ";
            while (curr != nullptr) {
                std::cout << curr -> data << " ";
                curr = curr -> next.get();
            }
            std::cout << "]" << std::endl;
        }
    };
}

#endif

main.cpp

int main() { //Temporary Test Main will be split from the implementation file in the future
    DLL::LinkedList <int> list; //Empty list
    list.append(1);
    list.append(4);
    list.append(5);
    list.append(6);
    list.print();
    list.remove(5);
    list.remove(1); //When 1 is removed the 4 doesn't properly update as head, meaning the previous pointer of 4 is not null
    list.remove(4);
    list.remove(6);
    list.print();
    retunn 0;
}

对于此类问题，我感到很抱歉，我进行了很多搜索，但找不到类似的内容。我正在调试这几天，但无法解决所有权问题。我尝试包含最少的代码，以重现错误，如果标头是长代码段，对不起。

我使用g ++：g++ -std=c++14 main.cpp -o out和VS2015编译器进行了编译。 make_unique调用需要C ++ 14标志

Answer 1

在要检查迭代器的上一个指针为空的部分（基本上检查头）中，有以下行：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_aktiviteetti1);

    //päävalikko on fragmentissa, joka pitää lisätä aktiviteettiin heti,
    //jollei sitä ole jo lisätty
    if (savedInstanceState==null) {     //this was missing original code
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentti1 = new PaaValikko();
        fragmentTransaction.add(R.id.aktiviteetti1Sisalto, fragmentti1);
        fragmentTransaction.commit();
    }

}

，它将标题指针移动到元素的下一个指针。但是，没有地方可以将新的头部指针的先前指针更新为null。因此该代码应为：

head = std::move(curr->next);

由于在要成为新的头部指针的项目上使用if(curr -> data == element){ //Found element if(curr -> prev == nullptr){ //is head head = std::move(curr->next); //Head now points to the next element if (head) head->prev = nullptr; else tail = nullptr; } }（这是正确的），因此基本上将该节点中包含的数据保持不变。在这种情况下，您需要明确-std::move包装器对其所拥有的对象的基础实现一无所知，因此在这种情况下，它不知道如何更新std::unique_ptr指针。

双向链接列表std :: unique_ptr类在删除节点时无法按预期工作

1 个答案: