移动 Person 对象列表的构造函数

如何解决移动 Person 对象列表的构造函数

我正在编写一个简单的代码，其中有一个 Person 类的对象列表。 Person类

class Person
{
    private:
        std::string name;
        std::string surname;
        int year;
        
    public:
        Person(const std::string& personName,const std::string& personSurname,const int& personYear ):
               name(personName),surname(personSurname),year(personYear) {}
               
        Person(const Person& p): name(p.name),surname(p.surname),year(p.year) { }
        
        Person(Person &&p) noexcept: name(std::move(p.name)),surname(std::move(p.surname)),year(std::move(p.year)) { }
        
        int getYear()
        {
            return year;
        }
        
        void print()
        {
            std::cout << name << " " << surname << " " << year << std::endl;
        }
};

其中，移动构造函数是

        Person(Person &&p) noexcept: name(std::move(p.name)),year(std::move(p.year)) { }

我也有节点结构

struct node
{
    Person data;
    node *next;
    inline node(const std::string& personName,const int& personYear): data(personName,personSurname,personYear),next(nullptr) { }
    inline node(const Person& personToInsert): data(personToInsert),next(nullptr) {} 
    inline node(Person &&personToInsert): data(std::move(personToInsert)),next(nullptr) {}
};

其移动构造函数是

    inline node(Person &&personToInsert): data(std::move(personToInsert)),next(nullptr) {}

最后我有了列表类

class list
{
    private:
    node *head;
    
    public:
    list();
    ~list();
    void insert(const std::string&,const std::string&,const int& );
    void insert(const Person& );
    void insert(Person &&);
    void print();
};

其移动构造函数是

void list::insert(Person &&personToInsert) {
    node *new_node = new node(std::move(personToInsert));
    if(head == nullptr || (head->data).getYear() >= (new_node->data).getYear())
    {
        new_node->next = head;
        head = new_node;
    }
    else
    {
        node *current = head;
        while(current->next != nullptr && (current->next->data).getYear() < (new_node->data).getYear())
        {
            current = current->next;
        }
        new_node->next = current->next;
        current->next = new_node;
    } 
}

我的问题是：在移动构造函数中，std::move的使用是否正确？特别是在list::insert

的第一行代码

解决方法

在移动构造函数中，std::move 的使用是否正确？

是的。

特别是在list::insert的第一行代码

这也是正确的。

但是请注意，我想指出两件小事。首先，无需为 Person 手动定义移动构造函数。如果您的类不进行手动资源处理（内存、IO 句柄等），只需依赖编译器为您生成的特殊成员函数。在这种情况下，我只需删除 Person 的移动和复制构造函数。

第二，

inline node(Person &&personToInsert)

是不是移动构造函数。它是一个普通的构造函数，碰巧接受一个右值引用参数。移动构造函数用于从它们自己类型的右值引用构造一个对象。

第三，

void list::insert(Person &&personToInsert)

根本不是构造函数——它是一个普通的成员函数，碰巧接受了一个右值参数。