C++ std::move 实现了什么功能？

沙雕喜剧人

c++11，增加了非常 重要的feature --- std::move。但很多解释不是很清楚。

从函数名看，以为是移动了数据的所有权，就像 std::unique_ptr，把内容指向的内存空间移到给另一变量。
实际情况是，std::move 真正做的是 shallow_copy，正常的赋值操作是deep_copy。

std::move原理

要更深层地理解这个问题，以a = std::move(b)为例。现在假定std::move用于所有权转移，那么有两个问题：

• b指定的内存空间被移动给a，那么b新的内存空间在哪里？
  
• a获取了b的内存空间，那么a原来的内存空间哪里去了？
  

还是回到代码
#include <iostream>

char strs[2][5] = {"str1", "str2"};

class A {
public:
  static int cnt_;
  int id = 0;
  char *p_str = nullptr;

public:
  A() {
    id = cnt_++;
    p_str = strs[id % 2];
    std::cout << "create A with id " << id << std::endl;
  }
  ~A() { std::cout << "destory A with id " << id << std::endl; }
};
int A::cnt_ = 0;

void test_move_object() {
  printf("===== test_move_object ====\n");
  A a1;
  A a2;
  printf("a1 %p [ id (%d %p) str (%s, point-to %p addr %p)]\n", &a1, a1.id,
         &a1.id, a1.p_str, a1.p_str, &a1.p_str);
  printf("a2 %p [ id (%d %p) str (%s, point-to %p addr %p)]\n", &a2, a2.id,
         &a2.id, a2.p_str, a2.p_str, &a2.p_str);

  printf("a1 = std::move(a2);\n");
  a1 = std::move(a2);
  printf("a1 %p [ id (%d %p) str (%s, point-to %p addr %p)]\n", &a1, a1.id,
         &a1.id, a1.p_str, a1.p_str, &a1.p_str);
  printf("a2 %p [ id (%d %p) str (%s, point-to %p addr %p)]\n", &a2, a2.id,
         &a2.id, a2.p_str, a2.p_str, &a2.p_str);

  printf("===========================\n\n\n");
}

void test_move_int() {
  printf("===== test_move_int ======\n");
  int int1 = 1, int2 = 3;
  printf(" int1 %d %p , int2 %d %p \n", int1, &int1, int2, &int2);
  int1 = std::move(int2);
  printf("int1 = std::move(int2);\n");
  printf(" int1 %d %p , int2 %d %p \n", int1, &int1, int2, &int2);
  printf("===========================\n\n\n");
}

int main() {
  test_move_int();
  test_move_object();
  return 0;
}运行结果为：
===== test_move_int ======
int1 1 0x7ffe6d4aac70 , int2 3 0x7ffe6d4aac74
int1 = std::move(int2);
int1 3 0x7ffe6d4aac70 , int2 3 0x7ffe6d4aac74
===========================


===== test_move_object ====
create A with id 0
create A with id 1
a1 0x7ffe6d4aac40 [ id (0 0x7ffe6d4aac40) str (str1, point-to 0x55b002d05018 addr 0x7ffe6d4aac48)]
a2 0x7ffe6d4aac50 [ id (1 0x7ffe6d4aac50) str (str2, point-to 0x55b002d0501d addr 0x7ffe6d4aac58)]
a1 = std::move(a2);
a1 0x7ffe6d4aac40 [ id (1 0x7ffe6d4aac40) str (str2, point-to 0x55b002d0501d addr 0x7ffe6d4aac48)]
a2 0x7ffe6d4aac50 [ id (1 0x7ffe6d4aac50) str (str2, point-to 0x55b002d0501d addr 0x7ffe6d4aac58)]
===========================
destory A with id 1
destory A with id 1

由运行结果可知，函数中涉及的所有内存空间在 std::move 时均无变化，最终只是基本数据类型(int/double/ptr/...)的值有了赋值操作。所以可以确定

std::move 只是shallow_copy操作。

std::move不适用的情况

由于是shallow-copy，所以相对于deep-copy操作，可以节省一些运行资源。但std::move在以下情况不可使用：
返回临时对象(-Wpessimizing-move)

此种情况，符合C++的Named Return Value Optimization(NRVO)准则，直接将临时返回值的所有权分配给外层分配对象。

注：此优化可通过给编译器设置-0优化级别来关闭。

struct T {
  // ...
};

T fn()
{
  T t;
  return t; // 不可使用 return std::move(t);
}

T t = fn ();如果给函数临时返回值使用了std::move，会得到如下代码（编译）提示：
t.C:8:20: warning: moving a local object in a return statement prevents copy elision [-Wpessimizing-move]
8 | return std::move (t);
  |        ~~~~~~~~~~^~~
t.C:8:20: note: remove ‘std::move’ call  返回函数传入参数（-Wredundant-move）


struct T {
  T(const T&) = delete;
  T(T&&);
};

T fn(T t)
{
  return t; // std::move已经被默认调用
}
如果再主动调用，会有代码提示：
r.C:8:21: warning: redundant move in return statement [-Wredundant-move]
8 | return std::move(t); // move used implicitly
  |        ~~~~~~~~~^~~
r.C:8:21: note: remove ‘std::move’ call需要明确使用std::move的情况

当返回 的对象与返回值的类型是继承关系，需要明确调用std::move，例如：
struct U { };
struct T : U { };

U f()
{
  T t;
  return std::move (t);
}

冷漠人

呵呵，低调，低调！