Как реализовать назначение копирования в двусвязном списке?

Question

Я немного запутался в том, как реализовать назначение копирования в двусвязном Списке. Мне удалось заставить конструктор копирования работать, но я не уверен в назначении. Я пытаюсь сделать это без метода копирования и обмена.

List.H

class List 
{
public:
    List();
    ~List();
    List(const List& c);
    List& operator= (const List& t);
private:
    List *Next;
    List *Prev;
    Node *Head;

List. cpp

List::~List()
{
    Node* move = Head;
    while (move!=NULL)
    {
        Node *temp = move->Next;
        delete move;
        move = temp;
    }
}

List::List(const List& c)
{
    name = c.name;
    Prev = c.Prev;
    Next = c.Next;
    Node* dummy, * current;
    Head= dummy = new Node();
    current = c.Head;
    while (current)
    {
        dummy->Next = new Node(*current);
        current = current->Next;
        dummy = dummy->Next;
    }

    Node* temp = Head;
    Head = Head->Next;
    delete temp;
}

List& List::operator=(const List& t)
{
    Next = t.Next;
    return *this;
}

Мне бы тоже пришлось пройти а также каждый узел в операторе присваивания?

Правка Итак, это то, что у меня сейчас. Проблема в том, что когда я получаю данные из списка, они становятся пустыми.

List& List::operator=(const List& that)
{

    if (this != &that)
    {
        while (Head)
        {
            Node* temp = Head;
                Head = Head->Next;
                delete temp;
        }
        Node* dummy, * current;
        Head = dummy = new Node();
        current = that.Head;
        while (current)
        {
            dummy->Next = new Node(*current);
            current = current->Next;
            dummy = dummy->Next;
        }
    dummy->Next = nullptr;
}
return *this;
}

Answer 1

Краткий ответ ДА.

1. конструктор копирования

    List L1;
    List L2(L1);

operator =

    List L1;
    List L2;
    L2 = L1;

В обоих случаях L1 должен быть скопирован в L2 и L1 должен быть неизменен после копирования или назначения , Следовательно, содержимое каждого узла должно быть реплицировано на вновь созданный узел.

Конструктор копирования выглядит примерно так:

List::List(const List& c)
{
    Node start;
    Node* dummy = &start;
    Node* CurrentNode = c.Head;
    while (CurrentNode)
    {
        dummy->next  = new Node(*CurrentNode);//New node created with content of *CurrentNode
        dummy = dummy->Next;
        CurrentNode  = CurrentNode->Next;
    }

    dummy->next = nullptr;
    Head = start.next;
}

И оператор присваивания выглядит так:

List& List::operator=(const List& that)
{
    if (this != &that) //avoid self assignment like List L1;L1=L1;
    {
       while (Head)//Delete exist nodes
       {
           Node* temp = Head;
           Head = Head->Next
           delete temp;
       }

        Node start;
        Node* dummy = &start;
        Node* thatHead = that.Head;
        while (thatHead)
        {
            dummy->next  = new Node(*thatHead);//New node created with content of *thatHead 
            dummy = dummy->Next;
            thatHead = thatHead->Next;
        }
        dummy->next = nullptr;
    }
    return *this;
}