移动语义：执行 std::move 时不执行构造函数和赋值

Question

#include <iostream>
#include <utility>
#include <vector>

class Node
{
public:
    int data;
    Node* prev;
    Node* next;
};

class Doublyll
{
private:
    Node* head;
    Node* tail;
public:
    Doublyll();
    Doublyll(std::vector<int> V);
    Doublyll(const Doublyll& source);
    Doublyll(Doublyll&& src) noexcept;
    Doublyll& operator=(const Doublyll& rhs);
    Doublyll& operator=(Doublyll&& src) noexcept;
    ~Doublyll();

    friend std::ostream& operator<<(std::ostream& os, const Doublyll& src);

    void Concatenate(Doublyll&& l2);
};

// Default Constructor will SET head and tail to nullptr
Doublyll::Doublyll()
    : head(nullptr), tail(nullptr)
{
}

// Explicit Constructor using vector
Doublyll::Doublyll(std::vector<int> V)
    : head(nullptr), tail(nullptr)
{
    Node** p = &head;

    for (auto& value : V)
    {
        Node* t = new Node;
        t->data = value;

        if (head == nullptr)
            t->prev = nullptr;
        else
            t->prev = tail;
        t->next = nullptr;

        *p = t;
        p = &(t->next);

        tail = t;
    }
}

// Copy Constructor
Doublyll::Doublyll(const Doublyll& source)
    : head(nullptr), tail(nullptr)
{
    std::cout << "Copy Construcor called!\n";

    Node** p = &head;

    // Iterate through all Node in source linked list, copying it to new object
    for (Node* tmp = source.head; tmp != NULL; tmp = tmp->next)
    {
        Node* t = new Node;
        t->data = tmp->data;
        if (head == nullptr)
            t->prev = nullptr;
        else
            t->prev = tail;
        t->next = nullptr;

        *p = t;
        p = &(t->next);

        tail = t;
    }
}

// Move Constructor
Doublyll::Doublyll(Doublyll&& src) noexcept
    : head(std::exchange(src.head, nullptr)), tail(std::exchange(src.tail, nullptr))
{
    std::cout << "Move Constructor called!\n";
}

// Copy Assignment Operator
Doublyll& Doublyll::operator=(const Doublyll& rhs)
{
    std::cout << "Copy Assignment Operator called!\n";

    // Check self assignment
    if (this != &rhs)
    {
        Doublyll tmp(rhs);
        std::swap(tmp.head, head);
        std::swap(tmp.tail, tail);
    }
    return *this;
}

// Move Assignment
Doublyll& Doublyll::operator=(Doublyll&& src) noexcept
{
    std::cout << "Move Assignment called!\n";

    if (this != &src)
    {
        std::swap(head, src.head);
        std::swap(tail, src.tail);
    }
    return *this;
}

// Destructor
Doublyll::~Doublyll()
{
    std::cout << "Desctructor called @ address " << &head << std::endl;

    Node* p = head;
    Node* tmp;

    while (p != nullptr)
    {
        tmp = p;
        p = p->next;
        delete tmp;
    }
}

// Display using Overloading << Operator
std::ostream& operator<<(std::ostream& os, const Doublyll& src)
{
    Node* tmp = src.head;

    if (tmp == NULL)
        std::cout << "(EMPTY)\n";
    else
    {
        for (; tmp != nullptr; tmp = tmp->next)
            std::cout << tmp->data << " ";
        std::cout << std::endl;
    }

    return os;
}

void Doublyll::Concatenate(Doublyll&& l2)
{
    // Since we have tail, we can connect it by using it
    tail->next = l2.head;
    l2.head->prev = tail;

    // Move first Node's tail to last Node of second linked list
    tail = l2.tail;
    
    // Make l2 as NULL
    /*l2.head = l2.tail = nullptr;*/
}

int main()
{
    // Create an Vector
    std::vector<int> v1 = { 1, 3, 5, 7, 9, 11 };
    std::vector<int> v2 = { 2, 4, 6, 8 };

    // Create object and linked list
    Doublyll l1(v1);
    Doublyll l2(v2);

    // Display linked list
    std::cout << l1;
    std::cout << l2;

    // Concatenate 2 linked list
    l1.Concatenate(std::move(l2));

    // Display agaian after concatenate, l1 should connect with l2. and l2 should be EMPTY
    std::cout << l1;
    std::cout << l2;

    std::cin.get();
}

在这段代码中，我尝试连接我使用 Vector 创建的 2 个链接列表。

在 main() 中，我使用 std::move l1.Concatenate(std::move(l2)); 调用，因为最后，在 l1 与 l2 连接之后，我希望 l2 变为NULL 以防止在调用析构函数时 Double Free。但是，似乎我创建的移动构造函数或移动赋值都没有被执行。

事情是这样的：

1. 我知道我不需要使用 std::move(l2)，我可以通过引用 void Doublyll::Concatenate(Doublyll& l2) 简单地传递 l1.Concatenate(l2)。它奏效了。但我想练习使用移动构造函数和赋值。
2. 您可以在void Doublyll::Concatenate(Doublyll&& l2) 中看到我评论过的这段代码：/*l2.head = l2.tail = nullptr;*/，我已经手动将l2 设为NULL。它会完美运行，不会导致双重释放。但是，如果我执行 std::move(l2) 我不需要手动完成，对吧？
3. 如果我像这样将旧对象移动到新对象，我的移动构造函数和移动赋值实际上是有效的：Doublyll l3(std::move(l2)); 和这样的l2 = std::move(l1);

那么，当我尝试像这样调用l1.Concatenate(std::move(l2)); 来连接两个链表时，为什么你认为它不起作用？我认为这就像在使 l2 不可访问（NULL）之前将 l2 移动到 l1。

std::move 不是那样工作的吗？或者我的代码可能有问题，或者还有另一种方式仍然使用 std::move 来执行这样的功能？也许你也可以向我解释一下这个移动语义。谢谢。

Answer 1

代码不起作用，因为您注释掉了使它起作用的部分，即

l2.head = l2.tail = nullptr;

您没有看到使用移动构造函数或移动赋值运算符，因为您没有编写任何使用它们的代码。你期待这里有什么东西会打电话给他们吗？

我不确定你的问题是什么，但我猜你对什么是移动语义有一个基本的误解。 std::move 所做的唯一一件事——曾经——是表明允许将某些东西传递给一个以T&& 作为参数的函数。当您编写一个采用T&&（又名“右值引用”）的函数时，您的责任是将内脏从您传递的东西中移出，并使其处于一种状态，它所能做的就是破坏而不会造成任何问题.这正是您手动将头指针设置为nullptr 时所做的。