移动构造函数窃取

🧑‍💻 User

In this lecture we’re going to learn about Move constructors, and this is a special kind of constructorthat is going to steal data from other objects.And those objects we steal from are going to be temporary objects that are going to be killed by thecompiler.Anyway.Let’s look at a simple example.We’re going to use a class called Point.The class is going to have two member variables X and Y, which are pointer to double.So this is going to allow us to see some things we really want to see in this lecture.The class is going to have a constructor and a bunch of other methods that are not shown here becausethey really aren’t important for what we want to see.But let’s look at the syntax we use to build from temporaries.Here we have a point object which is being built from another point object.So this would really use the copy constructor.But notice what we are building from it is a point that we are building in place here.So the constructor is going to be called from what we have in the parentheses here, and we’re goingto build a temporary point object whose sole purpose is to be used to build another point object, whichis going to be p three here.So the point of this entire lecture is to not waste the data that we had in this point that we haveas a parameter or argument here.We want to grab the data and and we don’t want to go through the trouble to build another point becausewe already have it as a temporary here and we want to steal data from it.Okay.So let’s try and really illustrate this better.We’re going to have a temporary object, both somewhere in memory, and it’s going to be a full point.It’s going to have a pointer to X, a pointer to Y, and these are going to be double pointers.The pointer to X is going to have some address which is ending in D three here.The pointer to Y is going to have another address which is ending in D four here and we’re going tohave content stored at these memory locations.So this is our temporary and suppose that what we are pointing to is something really expensive to build.Suppose it is a really heavy object and we don’t want to waste the data if we have it already constructedand it is going to be wasted because the moment we are done building from a temporary, the temporaryis going to be thrown away by the compiler and we don’t want to really waste.So what we can do is steal data from this temporary if we are building another object from it.So for example, here we are trying to build P three from our temporary here.So we’re going to grab the data from temporary and steal that and put that in our P three object.At this moment when we are building P three, it’s going to have these two pointers because these arethe member variables we have.And and the x pointer is going to be pointing to null pointer and the Y pointer is going to be pointingto null pointer by default.It’s not going to have any content, but we don’t want to go through the trouble to put in the contentbecause we already have the content in temporary.So what we can do is steal these pointers and make them stored in P three here.So for example, we can grab this pointer address and put that here in P three.We can grab this pointer address and put that in P three the pointer to Y and then after we are donewe can make these pointers in temporary pointer to nowhere.We can set them to null pointer and we will have effectively stolen data from the temporary and storedthe data in our P three object.And by stealing data like this, we have avoided the heavy work of setting up our own data in p threehere and this is really cool.Okay, so if we steal data, we’re going to have a case like this.The pointers in P three and the temporary are going to be the same.But to really completely steal the data, we’re going to reset the pointers in temporary and we’re goingto set them to null pointer.So in temporary we’re going to have a null pointer and it’s basically not going to be pointing anywhere.It’s not going to have any content.The temporary object is not going to have any content in here and the data will have moved in P threeand this is what we mean by stealing data.So this is all fine and good, but how do we do this in C plus plus?Well, we use a Move constructor.A Move constructor is a special kind of constructor whose sole job is to steal data from other objects.And this is the syntax you use to set it up.You say the name of the constructor and you pass your parameter like this.You say the class name and then you put two ampersand symbols and this is going to be your move constructor.When the compiler sees this syntax, it’s going to know that it is a move constructor and it is goingto use it to steal data from temporaries.So what it is really going to do, we’re going to steal the pointer in X, We store that in our object,we’re going to steal the pointer in Y and we’re going to store.That in our objects here.And then what we need to do is to set the pointers in our temporary to null.And we’re going to do that through a special function that we’re going to set up in our object, whichis going to reset all the pointers.And this is really how you do it.Okay.Before we go off and really try this in Visual Studio code, I want to show you a way we can force thecompiler to treat our object as a temporary and we pass this through a special facility we have in Cplus plus, which is called a Stdmove.We need to do this because sometimes the compiler is going to do some optimizations and it’s not goingto treat our temporary as a temporary and it is going to call the copy constructor.Instead, we want to force the compiler to treat our object here as a temporary.So that’s why we pass this through this stdmove function which is built into the C plus plus standardlibrary.So now that you have an idea about move constructors, let’s head over to Visual Studio code and playwith this a little more.Okay, Here we are in our working folder.The current project is Move Constructors.We’re going to grab our template files and we’re going to put them in place and we are going to openthis in Visual Studio code like we always do by dragging and dropping here.This is going to open our folder and we will open the Main.cpp file and clean it up a little bit.The first thing we want to do is to bring in the class we want to use to learn about this.And we will set up a class called Point as we have seen in the slides.So let’s do that.We’re going to set up a header file.I’m going to say point dot h for our header file and we’re going to put in an implementation file calledpoint dot CPP.Let’s do that and we are going to put in our class.Let’s start by the header file.We’re going to put in the class which is called point here.And let’s go through it a little bit.The class name is Point.It’s going to have a few private member variables.We’re going to have a pointer to double.We’re going to have two variables X and Y, which are of type double pointer.So they are pointers to double.And we have a function we will use to invalidate our null pointers.But we can ignore this for now.We’re going to come back to it in a little bit.So this is our constructor.It’s going to take two parameters.We have a destructor which is going to release the memory and we have a copy constructor here.You see it is taking the parameter by const reference.Let’s say this, here it is a copy constructor and if we go down we have a few setters.The first one is going to set X and it is going to dereference a pointer and put in our value.The second one is going to set y again.It is going to Dereference and put in our value and we are doing this dereferencing because our membervariables are pointers.We need to go through Dereferencing to get to what is pointed to by this pointer.You should know this by now.We will have a few getters.The first one is going to return X because x is a pointer by default and we’re going to return y inget Y here and we have a utility function which is going to print information about our point.So it’s going to print the x coordinate of a point and it’s going to print the y coordinate of a point.And here you see that we are dereferencing again because we are going through pointers.Let’s be consistent here and put the parentheses on this x guy here.Okay, this is our header file.I think it is pretty good and pretty easy to understand at this point in the course.So let’s do the CPP file.We’re going to put in the implementations for our point class here.We have the constructor implemented.We’re going to set up a new memory location because we have pointers in our member variables.We have to initialize them with valid memory.So that’s what we do here.We’re going to dynamically allocate memory on the heap and then we’re going to store in our data.This is the syntax to do that.We also have a copy constructor which is going to also allocate new memory from the heap and we’re goingto store in data from our source object.Notice that we are doing deep copy here.We’re not doing blind member wise copy, which would be shallow copy.We are doing deep copy because we want to have independent data in our constructor point object.Here we also have a destructor which is going to release memory that we have initialized in our constructorsand this class is pretty done by now.Let’s go back in the header and really verify this.Our setters are implemented in place, so this should work.Let’s close the left sidebar here and we’re going to go back to Main.We’re going to include our point, let’s say point dot H, and then we’re going to create a point object.So let’s, for example, create a point P one, and we’re going to put in data.We’re going to put in 10.0 and 15.0.Why not?Okay, let’s do this and we can.Print information about this object through the printing full member function here so we can do that.So let’s print this information here.We’re going to say P one print info and we’re going to try and build.We want to investigate that.Things are really working exactly as we expect.We’re going to bring up a terminal and we’re going to clear and run Rooster.If we do that, we’re going to see that in X, we have ten, in Y, we have 15, which is what we expecthere.Let’s put in 10.4, for example, and 15.6.Why not?And build again.We want to see our decimal points.The build is good.We can clear and run rooster and you see that.We see the data here and this is what we expect.Okay, so let’s try and create a copy of a point from a temporary.So what we’re going to do is say point and we’re going to say P three and we are going to constructthis point from a temporary The way we do that, we’re going to force the compiler to treat what we’regoing to pass here as a temporary.And to do that, we need to pass this through a facility called a Stdmove, as we saw in the slides.So let’s do that.We’re going to say Stdmove, and then we’re going to pass our point here.Again, you will have to just believe me here because we need to learn about the Move constructors,but we don’t have enough tools to really understand what Stdmove does.By now you can treat as something that is going to force the compiler to treat this point here as atemporary so that we can steal data from it.So you are basically telling the compiler this point is going to be destroyed anyway, so steal fromit if you can.This is what we’re telling the compiler.So we’re going to put in data.Let’s put in 20.5 and 5.8 and you can really put in anything.Then we’re going to see what happens here.Okay, So we have our call to build an object from another object.But what we are building from is a temporary.Okay, So let’s comment out the print information we had in front here because we don’t want this toconfuse us.And let’s see what we have in our constructors.We have a print out in the body of the copy constructor and we have an stdcout statement in the constructor,which is taking two parameters here.So let’s see what happens.We’re going to build this and see what we see on the terminal.We’re going to build with GCC and you see that the world is good down here so we can clear and run Rooster.Now we’re going to see that we have two constructors called and now we see that we have two constructorscalled.I think the first one is to build this point here, and this is going to make our code a little moreconfusing.So I am going to comment this out and we’re going to build it down.Okay.So the build is good.We can clear and run Rooster.We’re going to see that we have a constructor called which is going to build this temporary here andwe have the copy constructor called because it’s going to be copying from this temporary.So this is what we expect.If we try to build from a temporary by default, the compiler is going to use the copy constructor.And that’s what we see here.We see that the body of the copy constructor was executed and printed out this message here and we don’treally want to use a copy constructor because the copy constructor is going to do a lot of work.It’s going to allocate new memory locations, it’s going to copy data.But what we are building from is a temporary and it’s going to be thrown away and it’s going to be thrownout anyway.So why not steal data that we have inside?If you look at our model of the point class, you’re going to see that our member variables are pointers.So we can technically still pointers in our temporary and just steal the data and avoid the work todo all this new memory allocation.And we can just steal data that is already there.This is going to become attractive if the pointers you have in your member variables are pointing tosomething really expensive.Suppose you’re suppose your member variables is some string that is really huge and you have a pointerto that and you don’t really want to rebuild a memory location to copy that string into.So we can steal data if we can and avoid all that hard work.And we need to do that through a Move constructor.So we’re going to go in our header file and set up a Move constructor and we have seen that the syntaxfor a Move constructor is really straightforward.All you have to do is say the name of the class, then you specify your parameter by value and thenyou put two ampersand symbols here and then you say your source point and then you give your parametera name.Let’s use source point here.It’s going to work and then we’re going to implement this in the CPP file.And let’s go down and say that we want to do our Move constructor.We can copy the code we have for our copy constructor and adapt this a little bit.So we’re going to grab that and put that here and we’re going to adapt the parameter to make it a propermove constructor and let’s make sure the names are consistent here.So source point and source point here they are consistent and what we want to do in here, we don’twant to allocate for new memory.We’re just going to steal the pointer and what we do is going to say source point, get X, this isgoing to return us a pointer to the memory location in the source object, which is our temporary here.And then we’re going to do the same things for the Y member variable.So let’s do that.We’re going to say source point and get Y.Let’s save this properly.We’re going to call the function here.And by this point we will have stolen the pointers from the source point.But after we do this, why do we have this squiggly line?Do we have more than we need of these parentheses?I think we do.So this is right.Visual Studio code is happy.So now that we have stolen the pointers, we need to do something more.Because at this point our two objects will be pointing to the same memory locations and we don’t wantthat.Remember that after remember that when a point is destroyed, it is going to release the memory it ispointing to in its member variables X and Y.And we don’t want the temporary to release our memory because the memory belongs to us.Now we have stolen these pointers.So what we need to do is to invalidate the pointers in source point here and we can do that througha special function that we have seen here, which is called invalidate.It’s going to invalidate the pointers that the current project is pointing to.So we’re going to use this.You’re going to see that this is going to set the X pointer to null pointer and the Y pointer to nullpointer.And we can call that to do our dirty job here.So we’re going to do that in the copy constructor.So we’re going to say source point invalidate and we are able to access this method, which is privatein point because we are doing this from the point class.You really need to understand this.Some people might think because this method here is private, we wouldn’t have access to it if we calledit like this.But please take a look at where we are calling it from.We are in the point class, so and in the point class, we will have access to any private members ofthis class here and invalidate happens to be a member of this class and it is private so we can useit.And now we have our Move constructor set up.Let’s go down here and say that it is the body of our Move constructor and if we run the code now,the compiler is smart enough to realize that we have a move constructor in our class and it is goingto use it and steal data from the temporary.And this is really cool.So let’s prove this.We’re going to build and see what GCC says about this.We’re going to build and the world is going to be good.You see world finished successfully.We can clear and run roster now you see that we are building our temporary here but we are calling thebody of our move constructor and after we steal from the temporary here it is going to be destroyedbecause it’s no longer needed and it is going to be thrown away and the data is going to be belongingto 0.3.Now, if we print information in P3, let’s do that.We’re going to see that we have the data we had in our temporary here, and this is really cool.X is going to be 20.5 and Y is going to be 5.8.Let’s build and take into account the Printf statement here.We’re going to see that the build is good.We can clear and run roster.We’re going to see that.Our point now is going to have the data that we had in the temporary, but we didn’t go through thetrouble to set up new memory locations.We just stole what we had in our temporary here.And this is the job that move constructors.Do they steal from temporaries?Okay, so this is doing what we want, but I want you to see another trick we can use to really do thisin one step and not have to call the invalidate function.What we can do is set up a special getter functions which are going to steal the pointer and invalidatethe pointer in one go.And the way we can do that is to go back in our class definition and let’s go to where we have our gettersand we’re going to put in another set of getters that are going to steal the data and invalidate thepointer.So here we have Steal X, which is going to set up a new memory location.It’s going to steal X and store that in this new x pointer and then we’re going to invalidate x, we’regoing to set that to null pointer and then we’re going to return a new X here.The benefit of this is that we don’t have to call.Validate in the body of our move function.By the time we steal the pointer, we will also have a chance to invalidate it.And this is going to be pretty cool.We’re going to do the same logic for Steal here.And now that we have this in place, we could go in our Move constructor comment the invalidate callout and then call steal X.We don’t want to call get x.We want to call steal x.So we’re going to do that and we’re going to call steal y.And this is going to do what we want in one go.So some people prefer to do things like this, but it is a little less self-documenting.So I would prefer to use Invalidate here because when people see this call, they will at least havean intuition that we are invalidating data from the source object here and this is pretty cool.So we’re going to build and really prove that this is working and we don’t have any problem with this.You’re going to see that the build is good.We can clear and run Rooster.You’re going to see that we built our object from a temporary and it is working flawlessly.Here.We have the data from the temporary and we didn’t have to go through the job to build another object.We just stole the data that we had in our temporary here.Please remember to use Stdmove here because if you don’t, the compiler is not going to treat this asa temporary, at least in my case here.And you need to put Stdmove in here to make sure that the compiler is going to treat our temporary hereas a proper temporary and use the Move constructor to construct other objects from this temporary here.This is really all I had to share in this lecture.Hopefully you didn’t find it confusing.If you have any problems, please do ask and I will do the best I can to help you out.For now, we’re going to stop here in this lecture.In the next one, we’re going to learn about deleted constructors.Go ahead and finish up here and meet me there.

🤖 Assistant

好的，很高兴能为您详细讲解 C++ 中的移动构造函数！作为您学习 C++ 的向导，我会尽力用最清晰、最易懂的方式来阐述这个重要的概念。

C++ 深度解析：掌握移动构造函数——“窃取”数据的艺术

内容摘要： 本课程将带您深入理解 C++ 中的移动构造函数（[Move Constructor]），这是一种特殊的构造函数，它允许我们“窃取”其他对象（尤其是临时对象）的资源，而不是进行昂贵的复制。我们将通过一个具体的 Point 类示例，学习移动构造函数的工作原理、语法，以及如何通过 std::move 来启用移动语义，从而优化程序性能。

1. 什么是移动构造函数？为什么我们需要它？

在 C++ 中，当您创建一个新对象并用另一个现有对象来初始化它时，通常会发生两种情况：

拷贝构造函数（[Copy Constructor]）：当您从一个“L值”（[Lvalue]，即有明确内存地址、可以被重复使用的对象）创建另一个对象时，拷贝构造函数会被调用。它的任务是创建一个与源对象完全独立的副本，这意味着它可能会进行一次“深拷贝”（[Deep Copy]），为新的对象分配新的内存，并将源对象的数据复制过来。这在处理大型数据结构或动态分配的内存时，可能会非常耗费资源。
移动构造函数：而移动构造函数则是一种特殊的构造函数，它专门用于从“R值”（[Rvalue]，通常是临时对象，即表达式的临时结果，生命周期很短，不可重复使用）创建新对象。它的核心思想是：既然源对象是临时对象，反正很快就要被销毁了，为什么不直接“窃取”它的资源（比如它指向的内存）呢？这样就避免了重新分配内存和复制数据的开销，极大地提高了效率。

核心问题： 假设您的类管理着一些动态分配的、非常大的内存资源。当您通过一个临时对象来创建另一个对象时，如果仍然使用拷贝构造函数，那么就会发生一次昂贵的深拷贝：为新对象分配新的内存，然后将旧内存中的大量数据复制过来。而这个临时对象一旦完成其使命，它所持有的旧内存就会被释放。这整个过程就造成了资源的浪费和性能的下降。移动构造函数的出现，正是为了解决这种不必要的开销，实现更高效的资源转移。

2. 深入理解：移动构造函数的工作原理

让我们以一个 Point 类为例来具体说明。

2.1 `Point` 类设计

在我们的示例中，Point 类将包含两个私有成员变量 m_x 和 m_y，它们都是 double* 类型，即指向 double 类型的指针。这意味着 Point 对象本身并不直接存储坐标值，而是存储指向这些值的内存地址。坐标值 X 和 Y 将被动态地分配在堆（[Heap]）上。

cpp

// Point.h
#pragma once
#include <iostream>

class Point {
private:
    double* m_x; // 指向X坐标的指针
    double* m_y; // 指向Y坐标的指针

    // 辅助函数：将指针置空，用于在窃取资源后使源对象无效
    void invalidate();

public:
    // 构造函数
    Point(double x_val, double y_val);

    // 析构函数（[Destructor]）：释放动态分配的内存
    ~Point();

    // 拷贝构造函数：执行深拷贝
    Point(const Point& source);

    // *** 移动构造函数：窃取资源 ***
    // 参数是右值引用（[Rvalue Reference]），表示接受临时对象或可移动的对象
    Point(Point&& source) noexcept; // noexcept 关键字表示该函数不抛出异常

    // 拷贝赋值运算符 (为了完整性添加，虽然讲座未提及)
    Point& operator=(const Point& source);

    // 移动赋值运算符 (为了完整性添加，虽然讲座未提及)
    Point& operator=(Point&& source) noexcept;


    // Getter 方法
    double getX() const;
    double getY() const;

    // Setter 方法 (为简洁起见，放在头文件内联实现)
    void setX(double x_val) {
        if (m_x) *m_x = x_val;
    }
    void setY(double y_val) {
        if (m_y) *m_y = y_val;
    }

    // 打印信息
    void printInfo() const;

    // (可选) 窃取并返回指针的方法，同时使源对象指针无效
    // double* stealX();
    // double* stealY();
};

cpp

// Point.cpp
#include "Point.h"
#include <iostream>

// 构造函数实现
Point::Point(double x_val, double y_val) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用普通构造函数 ---" << std::endl;
    m_x = new double(x_val); // 动态分配内存
    m_y = new double(y_val);
}

// 析构函数实现
Point::~Point() {
    std::cout << "--- 调用析构函数 ---" << std::endl;
    if (m_x) {
        delete m_x; // 释放内存
        m_x = nullptr;
    }
    if (m_y) {
        delete m_y;
        m_y = nullptr;
    }
}

// 拷贝构造函数实现：执行深拷贝
Point::Point(const Point& source) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用拷贝构造函数 ---" << std::endl;
    if (source.m_x) {
        m_x = new double(*source.m_x); // 为新对象分配新内存并复制数据
    }
    if (source.m_y) {
        m_y = new double(*source.m_y);
    }
}

// 辅助函数：将当前对象的指针置空
void Point::invalidate() {
    m_x = nullptr;
    m_y = nullptr;
}

// *** 移动构造函数实现：窃取资源 ***
Point::Point(Point&& source) noexcept : m_x(source.m_x), m_y(source.m_y) {
    std::cout << "--- 调用移动构造函数 ---" << std::endl;
    // 窃取后，必须将源对象的指针置空，防止源对象析构时释放掉已被窃取的内存
    // 方式一：直接置空
    source.m_x = nullptr;
    source.m_y = nullptr;
    // 方式二：调用辅助函数
    // source.invalidate(); // 因为invalidate是private，但我们在Point类内部，所以可以访问
}

// 拷贝赋值运算符 (为了完整性添加)
Point& Point::operator=(const Point& source) {
    std::cout << "--- 调用拷贝赋值运算符 ---" << std::endl;
    if (this != &source) { // 防止自赋值
        // 释放旧资源
        if (m_x) delete m_x;
        if (m_y) delete m_y;

        // 分配新资源并深拷贝
        m_x = source.m_x ? new double(*source.m_x) : nullptr;
        m_y = source.m_y ? new double(*source.m_y) : nullptr;
    }
    return *this;
}

// 移动赋值运算符 (为了完整性添加)
Point& Point::operator=(Point&& source) noexcept {
    std::cout << "--- 调用移动赋值运算符 ---" << std::endl;
    if (this != &source) { // 防止自赋值
        // 释放旧资源
        if (m_x) delete m_x;
        if (m_y) delete m_y;

        // 窃取资源
        m_x = source.m_x;
        m_y = source.m_y;

        // 将源对象的指针置空
        source.m_x = nullptr;
        source.m_y = nullptr;
    }
    return *this;
}

// Getter 方法实现
double Point::getX() const {
    if (m_x) return *m_x;
    return 0.0; // 或者抛出异常，根据需求
}

double Point::getY() const {
    if (m_y) return *m_y;
    return 0.0; // 或者抛出异常
}

// 打印信息实现
void Point::printInfo() const {
    // 检查指针是否为空，避免解引用空指针
    std::cout << "Point Info: X = ";
    if (m_x) {
        std::cout << *m_x;
    } else {
        std::cout << "nullptr";
    }
    std::cout << ", Y = ";
    if (m_y) {
        std::cout << *m_y;
    } else {
        std::cout << "nullptr";
    }
    std::cout << std::endl;
}

/*
// (可选) 窃取并返回指针的方法，同时使源对象指针无效
double* Point::stealX() {
    double* temp_x = m_x;
    m_x = nullptr; // 将当前对象的X指针置空
    return temp_x;
}

double* Point::stealY() {
    double* temp_y = m_y;
    m_y = nullptr; // 将当前对象的Y指针置空
    return temp_y;
}
*/

2.2 “窃取”数据的机制

考虑以下场景：

cpp

1	Point p3 = Point(20.5, 5.8); // 这里的 Point(20.5, 5.8) 是一个临时对象

临时对象创建： 首先，Point(20.5, 5.8) 会创建一个临时 Point 对象。这个对象会在堆上动态分配内存来存储 X 和 Y 的值，并让 m_x 和 m_y 指向这些内存。
默认行为（无移动构造函数时）： 如果没有定义移动构造函数，编译器会调用拷贝构造函数。这意味着会为 p3 再次分配新的内存，并将临时对象中的 20.5 和 5.8 复制到 p3 的新内存中。然后，临时对象会被销毁，其原始的内存也会被释放。
移动构造函数的行为： 当定义了移动构造函数后，编译器会识别到它正在从一个临时对象（右值）创建 p3，因此它会选择调用移动构造函数。
- 步骤1：窃取指针。 移动构造函数不会分配新的内存。相反，它会将临时对象 source 的 m_x 和 m_y 指针的值直接复制给 p3 的 m_x 和 m_y。此时，p3 和 source 的指针都指向同一块内存。
- 步骤2：使源对象无效。 这是关键一步！为了确保在 source 销毁时不会错误地释放 p3 正在使用的内存（导致“双重释放”或“悬空指针”），移动构造函数会立即将 source 的 m_x 和 m_y 指针设置为 nullptr。这样，当 source 对象被销毁时，由于其指针已为空，就不会尝试释放它不再拥有的内存。
- 结果： 此时，原始的 20.5 和 5.8 的内存所有权已经从临时对象安全地转移到了 p3。临时对象在销毁时，不会触及这块内存。我们避免了昂贵的内存分配和数据复制。

2.3 移动构造函数的语法

移动构造函数的声明方式如下：

cpp

1	ClassName(ClassName&& source) noexcept;

ClassName: 您的类名。
&&：这就是 右值引用 符号，它表明这个构造函数接受一个右值（通常是临时对象）作为参数。
source: 源对象的名称，您可以从中窃取资源。
noexcept: 这是一个重要的关键字。它表明该函数承诺不会抛出异常。这对于移动操作非常重要，因为如果移动操作在中间抛出异常，C++ 标准库中的某些容器（如 std::vector）可能会选择进行更安全的拷贝操作，而不是移动，从而失去性能优势。

2.4 `std::move` 的作用

在某些情况下，您可能希望强制编译器将一个 L值（例如一个具名变量）视为一个 R值，从而使其能够被移动构造函数或移动赋值运算符处理。这时就需要用到 std::move。

cpp

1 2	Point p1(10.0, 15.0); // p1 是一个 L值 Point p4 = std::move(p1); // 强制将 p1 视为 R值，调用移动构造函数

重要！ std::move 本身并不执行任何移动操作。它仅仅是将一个左值表达式 转换（[Cast]） 为一个右值引用。这个转换告诉编译器：“嘿，这个对象我不再需要了，你可以安全地从它那里窃取资源了！”然后，编译器会根据这个右值引用，尝试匹配并调用移动构造函数（或移动赋值运算符），如果匹配成功，才会发生真正的“移动”。

如果 std::move 被省略，而参数又是一个 L值，那么编译器会调用拷贝构造函数（如果可用）或者报错。如果参数是一个 R值（如 Point(20.5, 5.8) 这样的临时对象），即使没有 std::move，编译器也能够自动识别并调用移动构造函数（如果已定义）。

2.5 `invalidate` 函数与“Steal Getters”（可选）

讲座中提到了两种处理源对象指针的方式：

在移动构造函数内直接调用 invalidate()： 这是一种清晰明了的方式。在窃取资源后，显式地调用一个辅助函数（如 invalidate()）将源对象的指针置空。

cpp

Point::Point(Point&& source) noexcept : m_x(source.m_x), m_y(source.m_y) {
    std::cout << "--- 调用移动构造函数 ---" << std::endl;
    source.invalidate(); // 清晰地表明：使源对象无效
}

这种方式的好处是，移动构造函数的主体清晰地展示了“窃取”和“失效”两个步骤，易于理解。

使用“Steal Getters”（如 stealX() / stealY()）： 这种方法将“获取指针”和“将源指针置空”这两个操作封装在一个 getter 方法中。

cpp

// 在Point.h中
// double* stealX();
// double* stealY();

// 在Point.cpp中
// double* Point::stealX() {
//     double* temp_x = m_x;
//     m_x = nullptr; // 将当前对象的X指针置空
//     return temp_x;
// }

// 在移动构造函数中调用
// Point::Point(Point&& source) noexcept : m_x(source.stealX()), m_y(source.stealY()) {
//     std::cout << "--- 调用移动构造函数 ---" << std::endl;
// }

这种方式可能看起来更简洁，因为它在初始化列表中就完成了指针的获取和源对象的失效。但讲座中提到，它可能“不太自文档化”（less self-documenting），因为它将失效逻辑隐藏在 getter 内部，读者可能需要深入到 getter 的实现才能理解其副作用。通常，更推荐在移动构造函数的主体中显式地将源指针置空或调用 invalidate 函数，以提高代码的可读性。

3. 完整代码示例

为了更好地演示，我们将把 Point 类（包含移动构造函数）和 main 函数放在一起。

Point.h (如上所示)

Point.cpp (如上所示)

main.cpp

cpp

#include "Point.h" // 包含Point类的头文件
#include <iostream>

int main() {
    std::cout << "--- 示例开始 ---" << std::endl;

    // 1. 创建一个普通Point对象
    Point p1(10.4, 15.6);
    p1.printInfo();
    std::cout << "p1的X地址: " << p1.getX() << " (实际内容)"; // 打印值，而不是地址
    std::cout << ", p1的Y地址: " << p1.getY() << " (实际内容)" << std::endl;

    std::cout << "\n--- 使用临时对象调用移动构造函数 ---" << std::endl;
    // Point(20.5, 5.8) 是一个临时对象（右值）
    // 编译器会自动识别并调用移动构造函数
    Point p3 = Point(20.5, 5.8);
    p3.printInfo();

    std::cout << "\n--- 使用 std::move 强制调用移动构造函数 ---" << std::endl;
    // p1 是一个 L值，需要通过 std::move 转换为右值引用才能调用移动构造函数
    Point p4 = std::move(p1);
    p4.printInfo();
    // 此时，p1 的资源已被窃取，其内部指针应为 nullptr
    // 访问 p1 的数据可能会导致未定义行为或返回默认值
    p1.printInfo(); // 预期：X = nullptr, Y = nullptr

    std::cout << "\n--- 验证 p1 是否被移动 ---" << std::endl;
    // 尝试修改 p4 的值，看是否影响 p1（应该不影响）
    p4.setX(99.0);
    p4.setY(88.0);
    p4.printInfo();
    p1.printInfo(); // 确认 p1 仍然是无效状态

    std::cout << "\n--- 验证拷贝构造函数在L值上的调用 ---" << std::endl;
    Point p5 = p4; // p4 是一个 L值，这里会调用拷贝构造函数
    p5.printInfo();
    p4.printInfo(); // p4 仍然有效

    std::cout << "\n--- 示例结束 ---" << std::endl;
    return 0;
}

运行上述代码，您将看到类似的输出：

Code

--- 示例开始 ---
--- 调用普通构造函数 ---
Point Info: X = 10.4, Y = 15.6
p1的X地址: 10.4 (实际内容), p1的Y地址: 15.6 (实际内容)

--- 使用临时对象调用移动构造函数 ---
--- 调用普通构造函数 ---
--- 调用移动构造函数 ---
--- 调用析构函数 --- // 临时对象 Point(20.5, 5.8) 被销毁
Point Info: X = 20.5, Y = 5.8

--- 使用 std::move 强制调用移动构造函数 ---
--- 调用移动构造函数 ---
--- 调用析构函数 --- // p1 被销毁，但其内容已移走，析构时不会释放资源
Point Info: X = 99, Y = 88
Point Info: X = nullptr, Y = nullptr // p1 已经被移动，资源已置空

--- 验证 p1 是否被移动 ---
Point Info: X = 99, Y = 88
Point Info: X = nullptr, Y = nullptr

--- 验证拷贝构造函数在L值上的调用 ---
--- 调用拷贝构造函数 ---
Point Info: X = 99, Y = 88
Point Info: X = 99, Y = 88

--- 示例结束 ---
--- 调用析构函数 --- // p5 销毁
--- 调用析构函数 --- // p4 销毁
--- 调用析构函数 --- // p3 销毁

从输出中可以看到，当从临时对象或通过 std::move 创建新对象时，会调用“移动构造函数”，而不是“拷贝构造函数”，从而避免了不必要的深拷贝。同时，源对象的析构函数在资源被移动后，也不会尝试释放已经不再属于它的内存。

4. QA 闪卡

Q: 移动构造函数的主要目的是什么？
A: 避免不必要的昂贵拷贝操作，通过“窃取”临时对象或即将销毁的对象的资源来提高效率。
Q: 移动构造函数的参数类型是什么？它与拷贝构造函数有何不同？
A: 移动构造函数的参数是右值引用（ClassName&&），而拷贝构造函数的参数是常量左值引用（const ClassName&）。
Q: 为什么在移动构造函数中，我们需要将源对象的指针置空？
A: 防止源对象在销毁时，错误地释放掉已经被“窃取”的内存，从而避免“双重释放”（[Double Free]）或“悬空指针”（[Dangling Pointer]）问题。
Q: std::move 函数的作用是什么？它真的“移动”了数据吗？
A: std::move 不会移动数据，它仅仅是将一个左值强制转换为右值引用，从而告诉编译器这个对象可以被移动。真正的移动是由后续调用的移动构造函数或移动赋值运算符完成的。
Q: 什么时候编译器会优先选择调用移动构造函数而不是拷贝构造函数？
A: 当初始化新对象时，如果源对象是一个右值（例如，一个临时对象或通过 std::move 转换的左值），并且类定义了移动构造函数，那么编译器会优先调用移动构造函数。

5. 常见误解或错误

误解：std::move 会直接执行移动操作。
纠正： std::move 只是一个类型转换（[Type Cast]），它将表达式转换为右值引用类型，使其有资格被移动构造函数或移动赋值运算符调用。实际的移动操作（资源的转移）是在这些特殊的成员函数中完成的。
错误：在移动构造函数中忘记将源对象的指针置空。
后果： 这会导致“双重释放”错误。新对象和源对象会同时指向同一块内存。当源对象销毁时，它会释放这块内存；当新对象销毁时，它会再次尝试释放同一块内存，导致程序崩溃。
误解：移动构造函数总是比拷贝构造函数快。
纠正： 对于那些不管理动态资源（如 int、double 等基本类型）的简单类，或者当对象的拷贝成本非常低时，移动操作可能不会带来显著的性能提升。甚至在某些情况下，编译器可能会进行“返回值优化”（[Return Value Optimization] - RVO）或“命名返回值优化”（[Named Return Value Optimization] - NRVO），直接在目标位置构造对象，此时拷贝或移动构造函数根本不会被调用，性能最高。
错误：将移动构造函数的参数声明为 const ClassName&& source。
后果： const 关键字表示源对象不能被修改。这意味着在移动构造函数内部，您将无法将 source.m_x 和 source.m_y 设置为 nullptr，从而无法正确地“窃取”资源。移动操作的核心就是修改源对象的状态（使其失效）。因此，移动构造函数的参数不能是 const。
误解：只要定义了移动构造函数，编译器就会自动为所有情况选择移动。
纠正： 编译器选择调用移动构造函数的前提是源对象必须是右值。如果源对象是一个具名左值，您仍然需要显式地使用 std::move 来“建议”编译器进行移动操作。

6. 编程练习

现在，是时候动手实践了！请完善以下 Point 类中的移动构造函数。

任务：
给定了 Point.h 和 Point.cpp 的部分代码，请您在 Point.cpp 中完成 Point(Point&& source) 移动构造函数的实现。您需要完成以下两个关键步骤：

将 source 对象所管理的资源（m_x 和 m_y 指针指向的内存）“窃取”到新对象中。
将 source 对象的 m_x 和 m_y 指针设置为 nullptr，以确保 source 对象在销毁时不会错误地释放资源。

Point.h (不要修改此文件)：

cpp

#pragma once
#include <iostream>

class Point {
private:
    double* m_x;
    double* m_y;

public:
    // 构造函数
    Point(double x_val, double y_val);

    // 析构函数
    ~Point();

    // 拷贝构造函数
    Point(const Point& source);

    // *** 请实现此函数：移动构造函数 ***
    Point(Point&& source) noexcept;

    // Getter 方法
    double getX() const;
    double getY() const;

    // 打印信息
    void printInfo() const;
};

Point.cpp (请补充 Point::Point(Point&& source) 的实现)：

cpp

#include "Point.h"
#include <iostream>

// 构造函数实现 (已提供)
Point::Point(double x_val, double y_val) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用普通构造函数 ---" << std::endl;
    m_x = new double(x_val);
    m_y = new double(y_val);
}

// 析构函数实现 (已提供)
Point::~Point() {
    std::cout << "--- 调用析构函数 ---" << std::endl;
    if (m_x) {
        delete m_x;
        m_x = nullptr;
    }
    if (m_y) {
        delete m_y;
        m_y = nullptr;
    }
}

// 拷贝构造函数实现 (已提供)
Point::Point(const Point& source) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用拷贝构造函数 ---" << std::endl;
    if (source.m_x) {
        m_x = new double(*source.m_x);
    }
    if (source.m_y) {
        m_y = new double(*source.m_y);
    }
}

// *** 请在这里实现移动构造函数 ***
Point::Point(Point&& source) noexcept {
    // 步骤1: 窃取源对象的资源
    // 将 source 的 m_x 和 m_y 指针的值直接赋给当前对象的 m_x 和 m_y
    // 例如：this->m_x = source.m_x;

    // 步骤2: 使源对象无效
    // 将 source 的 m_x 和 m_y 指针置空
    // 例如：source.m_x = nullptr;

    std::cout << "--- 调用移动构造函数 ---" << std::endl; // 这一行保留
}

// Getter 方法实现 (已提供)
double Point::getX() const {
    if (m_x) return *m_x;
    return 0.0;
}

double Point::getY() const {
    if (m_y) return *m_y;
    return 0.0;
}

// 打印信息实现 (已提供)
void Point::printInfo() const {
    std::cout << "Point Info: X = ";
    if (m_x) {
        std::cout << *m_x;
    } else {
        std::cout << "nullptr";
    }
    std::cout << ", Y = ";
    if (m_y) {
        std::cout << *m_y;
    } else {
        std::cout << "nullptr";
    }
    std::cout << std::endl;
}

main.cpp (用于测试您的实现，无需修改)：

cpp

#include "Point.h"
#include <iostream>

int main() {
    std::cout << "--- 测试移动构造函数 ---" << std::endl;

    // 情况1: 从临时对象构造 (应调用移动构造函数)
    Point p1 = Point(10.0, 20.0); // 临时对象 Point(10.0, 20.0) 是右值
    p1.printInfo();

    std::cout << "\n--- 使用 std::move 从左值构造 (应调用移动构造函数) ---" << std::endl;
    Point temp_point(30.0, 40.0); // temp_point 是一个左值
    Point p2 = std::move(temp_point); // 强制转换为右值引用
    p2.printInfo();
    temp_point.printInfo(); // 验证 temp_point 是否已被移动（其指针是否为nullptr）

    std::cout << "\n--- 从左值构造 (应调用拷贝构造函数) ---" << std::endl;
    Point p3 = p1; // p1 是一个左值，应调用拷贝构造函数
    p3.printInfo();
    p1.printInfo(); // p1 应该仍然有效

    std::cout << "\n--- 测试结束 ---" << std::endl;
    return 0;
}

请完成 Point.cpp 中的 Point::Point(Point&& source) noexcept 的实现，然后告诉我您的解决方案。我会在您的解决方案提交后，给出我的评价、正确答案以及进一步的建议。

🧑‍💻 User

cpp

#include "Point.h"
#include <iostream>

// 构造函数实现 (已提供)
Point::Point(double x_val, double y_val) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用普通构造函数 ---" << std::endl;
    m_x = new double(x_val);
    m_y = new double(y_val);
}

// 析构函数实现 (已提供)
Point::~Point() {
    std::cout << "--- 调用析构函数 ---" << std::endl;
    if (m_x) {
        delete m_x;
        m_x = nullptr;
    }
    if (m_y) {
        delete m_y;
        m_y = nullptr;
    }
}

// 拷贝构造函数实现 (已提供)
Point::Point(const Point& source) : m_x(nullptr), m_y(nullptr) {
    std::cout << "--- 调用拷贝构造函数 ---" << std::endl;
    if (source.m_x) {
        m_x = new double(*source.m_x);
    }
    if (source.m_y) {
        m_y = new double(*source.m_y);
    }
}

// *** 请在这里实现移动构造函数 ***
Point::Point(Point&& source) noexcept
: m_x(source.m_x), m_y(source.m_y)
{
    // 步骤1: 窃取源对象的资源
    // 将 source 的 m_x 和 m_y 指针的值直接赋给当前对象的 m_x 和 m_y
    // 例如：this->m_x = source.m_x;

    // 步骤2: 使源对象无效
    // 将 source 的 m_x 和 m_y 指针置空
    // 例如：source.m_x = nullptr;
    source.m_x = nullptr;
    source.m_y = nullptr;

    std::cout << "--- 调用移动构造函数 ---" << std::endl; // 这一行保留
}

// Getter 方法实现 (已提供)
double Point::getX() const {
    if (m_x) return *m_x;
    return 0.0;
}

double Point::getY() const {
    if (m_y) return *m_y;
    return 0.0;
}

// 打印信息实现 (已提供)
void Point::printInfo() const {
    std::cout << "Point Info: X = ";
    if (m_x) {
        std::cout << *m_x;
    } else {
        std::cout << "nullptr";
    }
    std::cout << ", Y = ";
    if (m_y) {
        std::cout << *m_y;
    } else {
        std::cout << "nullptr";
    }
    std::cout << std::endl;
}

🤖 Assistant

太棒了！您的解决方案非常出色，完全正确地实现了移动构造函数的逻辑。

7. 您的解决方案评分及解释

您的解决方案：

cpp

Point::Point(Point&& source) noexcept
: m_x(source.m_x), m_y(source.m_y) // 在初始化列表中窃取资源
{
    // 步骤1: 窃取源对象的资源 - 已经通过初始化列表完成
    // 将 source 的 m_x 和 m_y 指针的值直接赋给当前对象的 m_x 和 m_y

    // 步骤2: 使源对象无效
    // 将 source 的 m_x 和 m_y 指针置空
    source.m_x = nullptr; // 正确！
    source.m_y = nullptr; // 正确！

    std::cout << "--- 调用移动构造函数 ---" << std::endl;
}

评分： 5/5 分！完美！

解释：

窃取资源（[Resource Acquisition]）的正确性：
您在初始化列表 (: m_x(source.m_x), m_y(source.m_y)) 中完成了资源窃取。这是 C++ 中实现移动构造函数的最佳实践。它直接使用 source 的指针值来初始化当前对象的 m_x 和 m_y，避免了先默认初始化成员变量再赋值的额外开销（尽管在这个例子中开销很小，但这是一个好习惯）。
源对象失效（[Source Invalidation]）的正确性：
您在构造函数体中正确地将 source.m_x 和 source.m_y 设置为 nullptr。这是移动构造函数中至关重要的一步，确保了：
- 所有权转移（[Ownership Transfer]）： 资源的唯一所有权从 source 转移到了新创建的对象。
- 避免双重释放（[Double Free Prevention]）： 当 source 对象生命周期结束并调用其析构函数时，由于其指针已为空 (nullptr)，它不会尝试释放已被新对象“窃取”的内存，从而避免了内存错误和程序崩溃。
- 源对象安全使用： source 对象虽然失去了资源，但其内部状态是明确的（指针为 nullptr），即使被误用也不会导致野指针（[Wild Pointer]）解引用等未定义行为（[Undefined Behavior]）。
noexcept 关键字的使用：
虽然在练习中没有明确要求添加 noexcept，但您的 Point::Point(Point&& source) noexcept 声明中包含它，这表明您对移动构造函数的特性有很好的理解。移动构造函数通常被声明为 noexcept，因为它不应该抛出异常。如果移动操作可能抛出异常，那么 std::vector 等标准库容器在需要重新分配内存时，可能会选择调用拷贝构造函数（即使移动构造函数存在），从而失去性能优势。

综上所述，您的代码简洁、高效、正确且符合现代 C++ 的最佳实践。干得漂亮！

8. 扩展问题及建议

既然您已经掌握了移动构造函数，我们可以进一步探索相关概念，这将帮助您更好地理解 C++ 的移动语义（[Move Semantics]）和资源管理。

移动赋值运算符（[Move Assignment Operator]）：
您已经学会了如何通过移动构造函数从右值创建新对象。那么，当您想将一个右值赋值给一个已存在的对象时，C++ 会调用什么？
- 思考： 移动赋值运算符的声明和实现与移动构造函数有何相似和不同之处？它需要处理哪些额外的情况（例如，目标对象可能已经持有了资源）？
- 建议： 尝试为 Point 类实现一个移动赋值运算符 Point& operator=(Point&& source) noexcept;。
std::unique_ptr 和 std::shared_ptr：
在现代 C++ 中，我们通常不直接使用裸指针（[Raw Pointer]）进行资源管理（如 new 和 delete），而是使用智能指针（[Smart Pointer]）。
- 思考： std::unique_ptr 默认就支持移动语义，但不支持拷贝。这与 Point 类中的移动构造函数概念有何异曲同工之处？它如何防止双重释放？
- 建议： 学习 std::unique_ptr 和 std::shared_ptr 的基本用法，并尝试将 Point 类中的 double* 成员替换为 std::unique_ptr<double>。您会发现，一旦使用了智能指针，您通常就不需要手动编写析构函数、拷贝/移动构造函数和赋值运算符了（这被称为“零规则”或“三/五规则”的现代版本）。
完美转发（[Perfect Forwarding]）和万能引用（[Universal Reference]）：
std::move 和 std::forward 是 C++11 引入移动语义时常用的两个工具。std::move 用于将左值转换为右值引用，而 std::forward 则用于实现完美转发。
- 思考： 万能引用（T&&，当 T 是模板参数时）如何根据传入参数的左右值属性，自动推导出 T 的类型？完美转发如何结合万能引用和 std::forward 来保持参数的左右值属性，将其转发给另一个函数？
- 建议： 了解模板函数中万能引用和 std::forward 的工作原理，这对于编写通用的库代码非常重要。
编译器优化（[Compiler Optimizations]）：RVO/NRVO：
在某些情况下，即使没有移动构造函数，您也可能观察到代码的性能与移动操作类似。这通常是由于编译器进行了“返回值优化”（RVO）或“命名返回值优化”（NRVO）。
- 思考： RVO/NRVO 是什么？它们是如何工作的？它们何时发生？它们的存在是否意味着我们不需要编写移动构造函数？
- 建议： 查阅关于 RVO/NRVO 的资料，理解它们如何减少临时对象的创建和复制，以及它们与移动语义之间的关系。

通过深入研究这些主题，您将对 C++ 的性能优化、资源管理和高级特性有更全面的理解。祝您学习愉快！

移动构造函数窃取

🧑‍💻 User

🤖 Assistant

C++ 深度解析：掌握移动构造函数——“窃取”数据的艺术

1. 什么是移动构造函数？为什么我们需要它？

2. 深入理解：移动构造函数的工作原理

2.1 Point 类设计

2.2 “窃取”数据的机制

2.3 移动构造函数的语法

2.4 std::move 的作用

2.5 invalidate 函数与“Steal Getters”（可选）

3. 完整代码示例

Point.h (如上所示)

Point.cpp (如上所示)

main.cpp

4. QA 闪卡

5. 常见误解或错误

6. 编程练习

🧑‍💻 User

🤖 Assistant

7. 您的解决方案评分及解释

8. 扩展问题及建议

2.1 `Point` 类设计

2.4 `std::move` 的作用

2.5 `invalidate` 函数与“Steal Getters”（可选）