c++ - 如何在链表类中实现赋值运算符

Question

我很难弄清楚如何在我的双向链表类中实现 5 规则。我明白了它们的概念，只是不知道如何编码。我已经尝试过析构函数和复制运算符，但仍然坚持其余部分。感谢您提供任何帮助/指导，谢谢。

析构函数/复制:

~DList() {

    Node* current = front_;

    while (current != back_)
    {
            front_ = front_->next_;
            delete current;
            current = front_;

    }

}

    // copy ctor
    DList(const DList& rhs) {

            const Node* current = rhs.front_;
            Node* temp = nullptr;

            if (current != back_)
            {
                    front_ = new Node(current->data_);
                    temp = front_;
                    current = current->next_;
            }
            while(current != back_)
            {
                    Node* nn = new Node(current->data_);
                    temp->next_ = nn;
                    temp = temp->next_;
                    current = current->next_;
            }

    } 

DList& operator=(const DList& rhs){ //copy assignment // <<---not sure where to begin

列表构造函数:

    DList() {


        //Node* front_;
            front_ = new Node(); // creating front sentinel 
                                                     //Node* back_; 
            back_ = new Node(); // creating back sentinel
                                                    //make them point to eachother
            front_->next_ = back_;
            back_->prev_ = front_;
            listSz = 0;

    }

主要内容:

    DList<int> list;
    DList<int> list2;
    DList<int>::const_iterator it;

    cout << list.size() << endl;
    list.push_front(1);
    list.push_front(2);
    list.push_back(3);
    list.push_front(4);
    list.print();

    std::cout << endl;

    list2.push_front(11);
    list2.push_front(12);
    list2.push_back(13);
    list2.push_front(14);
    list2.print();

    list2 = list;
    list2.print();

Answer 1

如果你有一个工作复制构造函数(它不使用赋值运算符)和析构函数，赋值运算符可以简单地是这样的:

 #include <algorithm>
 //...
 DList& operator=(const DList& rhs)
 {
     DList temp(rhs);
     std::swap(temp.front_, front_);
     std::swap(temp.back_, back_);
     std::swap(temp.listSz, listSz);
     return *this;
 }

这基本上使用了 copy / swap idiom .从传入的 DList 创建一个临时对象，临时对象的内部与当前对象的内部交换。然后临时的与旧的内部结构一起消失。