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

受到CppCon2016中Herb Sutter谈话的启发，可以在此链接中找到。
我决定使用智能指针实现视频中所示的双向链接列表。
以下实现几乎与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标志