c++11中的move是否会改变对象的地址

C++11中引入的移动语义，这个move操作是否会改变对象的地址，测试程序如下：

#include <iostream>
#include <string>
#include <cstdio>

using namespace std;

string func(int n)
{
    string s = "";
    for(int i = 0; i < n; i++)
        s += ('A' + i);
    cout << "in func , s : " << s << std::endl;
    printf("in func , s arrd : %lu
", (long unsigned int)&s);
    printf("in func , s data addr : %lu
", (long unsigned int)s.data());
    
    return std::move(s);
}


int main()
{
    string ret = func(30);
    
    std::cout << "ret : " << ret << std::endl;
    printf("in main , ret addr : %lu
", (long unsigned int)&ret);
    printf("in main , ret data addr : %lu
", (long unsigned int)ret.data());
    
    return 0;
}

运行结果：

可以看到，s的地址和ret的地址是不一样的，而它们底层引用的数据的地址是一样的。

也就是说元数据的地址会改变，但是底层的真正存储数据的地址不变，这也是move的作用，减少底层的数据的拷贝。

例子2：

#include <iostream>
#include <cstdio>

using namespace std;

class test_data
{
public:
    test_data()
    {
        std::cout << "test_data()" << std::endl;
    }
    
    test_data(const test_data& d)
    {
        std::cout << "test_data(const test_data& d)" << std::endl;
    }
    
    ~test_data()
    {
        std::cout << "~test_data()" << std::endl;
    }
};


test_data func()
{
    test_data t;
    
    return t;
}

int main()
{
    test_data ret = func();
    
    return 0;
}

结果1：

 

结果一中，编译时禁止rvo优化，可以看到经历了一次构造，和两次拷贝构造。

 

一次构造是28行的t构造，拷贝构造是func返回时，将结果拷贝构造给了临时对象，紧接着t析构，临时对象又拷贝构造给了ret，接着临时对象析构，最后ret析构。

 

 

 

不禁止rvo优化的话，结果如下：

 

 

 

下面添加move：

 

 

#include <iostream>
#include <cstdio>

using namespace std;

class test_data
{
public:
    test_data()
    {
        std::cout << "test_data()" << std::endl;
    }
    
    test_data(const test_data& d)
    {
        std::cout << "test_data(const test_data& d)" << std::endl;
    }
    
    ~test_data()
    {
        std::cout << "~test_data()" << std::endl;
    }
};


test_data func()
{
    test_data t;
    
    return std::move(t);
}

int main()
{
    test_data ret = func();
    
    return 0;
}

 

第30行添加了move。注意，没有实现移动构造。

结果1：

 

 

 

 禁止rvo优化时加不加move都一样。

结果2：

 

 

 

 开了rvo优化，只是少了临时对象的构造。

现在看来，开了rvo优化不用move的时候，优化力度更强一些，那个时候只有一次构造和一次析构。

使用move时，类应该有对应的移动构造函数才可以，新代码：

#include <iostream>
#include <cstdio>

using namespace std;

class test_data
{
public:
    test_data()
    {
        p = new char[1024];
        std::cout << "test_data()" << std::endl;
    }
    
    test_data(const test_data& d)
    {
        p = new char[1024];
        std::cout << "test_data(const test_data& d)" << std::endl;
    }
    
    test_data(const test_data&& d)
    {
        p = d.p;
        const_cast<test_data&>(d).p = nullptr;
        std::cout << "test_data(const test_data&& d)" << std::endl;
    }
    
    ~test_data()
    {
        delete p;
        std::cout << "~test_data()" << std::endl;
    }
    
public:
    char *p;
};


test_data func()
{
    test_data t;
    
    std::cout << "in func , t addr : " << (long unsigned int)&t << std::endl;;
    std::cout << "in func , t data addr : " << (long unsigned int)t.p << std::endl;;
    
    return std::move(t);
}

int main()
{
    test_data ret = func();
    
    std::cout << "in main , ret addr : " << (long unsigned int)&ret << std::endl;
    std::cout << "in main , ret data addr : " << (long unsigned int)ret.p << std::endl;
    
    return 0;
}

结果：

 

如果只定义了移动构造而没有使用move，例如第46行直接是return t，这种情况下，编译器也会进行优化，还是会调用到移动构造。代码就改46这一行，运行结果：

 

 依然走到了移动构造。

加上move只是让语义更加明确。