Home / Questions / 854
Accepted
eferion
Asked: 2020-12-11 01:35:59 +0800 CST 2020-12-11 01:35:59 +0800 CST

何时使用 std::move 以及为什么？

  • 772

推荐在什么场景下使用std::move？

std::vector<int> func()
{
  std::vector<int> toReturn(1000000,5);
  return std::move(toReturn); // 1
}

int main()
{
  std::vector<int> datos = std::move(func()); // 2

  // operaciones varias
}

在上面的例子中，是std::move? 为什么？滥用 std::move 会产生什么影响？

c++

2 Answers

  1. Best Answer

    它有什么作用std::move？

    std::move将 a 转换Lvalue为 a Rvalue。

    它有什么用std::move？

    C++11 向目录添加了一个新的构造函数。你的签名是POO(POO&&). 如果已定义此构造函数，则在接收到 a 时会自动调用Rvalue它，其功能是将一个对象的状态转移到另一个对象，避免对其进行复制。

    C++11 还允许您使用新的赋值运算符，其签名为POO& operator=(POO&&).

    这两个新特性可以共存，没有复制构造函数和所有生命的赋值问题。请记住，实现复制构造函数会禁用默认构造函数实现move，反之亦然。以上也适用于赋值运算符。

    对于重物来说，这可能是一个显着的性能改进。一个例子：

    class ObjetoPesado
{
  private:

    const int NumDatos = 1000000;
    int* _datos;

  public:

    ObjetoPesado()
      : _datos(new int[NumDatos])
    {
    }

    ObjetoPesado(ObjetoPesado&& origen)
      : _datos(nullptr)
    {
      std::swap(_datos,origen._datos);
    }

    ObjetoPesado(const ObjetoPesado& origen)
      : ObjetoPesado() // Llamada al constructor por defecto,
                       // soportado desde C++11
    {
      std::copy(origen._datos,
                origen._datos+NumDatos,
                _datos);
    }

    ~ObjetoPesado()
    {
      delete[] _datos;
    }
};

int main()
{
  clock_t start = clock();
  for( auto i=0; i<10000; i++ )
  {
    ObjetoPesado origen;
    ObjetoPesado* copia = new ObjetoPesado(origen); // Constructor copia
    delete copia;
  }
  std::cout << "copia: " << static_cast<double>(clock()-start) / CLOCKS_PER_SEC << std::endl;

  start = clock();
  for( auto i=0; i<10000; i++ )
  {
    ObjetoPesado origen;
    ObjetoPesado* copia = new ObjetoPesado(std::move(origen)); // Constructor move
    delete copia;
  }
  std::cout << "move: " << static_cast<double>(clock()-start) / CLOCKS_PER_SEC << std::endl;
}

    尽管将指针从一个地方复制到另一个地方似乎比复制所有涉及的内存要轻得多，但如果您运行该示例，它会变得更清楚。在发行版中运行此代码，在我的机器上它给出以下时间：

    copia: 22.929
move: 0.034

    同样清楚的是，只有当对象（直接或间接）使用动态内存时，移动语法才有意义，因为这种改进仅适用于指针。

    使用的缺点std::move是原始对象失去了它的状态。通常这不应该是一个问题，因为这些语义的调用不是随机的。

    什么时候应该使用 std::move？

    move正如@Angel-Angel 所指出的，语法可以通过调用自动执行return。这应该是当前编译器优化目录的一部分。在这种情况下，以下两个函数是等效的。

    ObjetoPesado func1()
{
  ObjetoPesado toReturn;
  return toReturn;
}

ObjetoPesado func2()
{
  ObjetoPesado toReturn;
  return std::move(toReturn);
}

    但是，如果std::move它通常是隐式调用的，你应该什么时候使用它呢？

    大多数情况下，这个函数主要用于构造函数和赋值实现move，因为我们确保嵌套对象从这种优化中受益：

    class POO
{
  private:
    std::string _cadena;

  public:

    POO(POO&& original)
      : _cadena(std::move(original._cadena)) // Invocamos el constructor
                                             // move de std::string
    { }
};

    在使用std::unique_ptr. 特别是当它们在容器中时。如果我们想在std::unique_ptr向量中狂提取或插入a，程序将无法直接编译：

    int main()
{
  std::unique_ptr<int> ptr(new int(1));
  *ptr = 100;

  std::vector<std::unique_ptr<int>> datos;
  datos.push_back(ptr);            // ERROR
  datos.push_back(std::move(ptr)); // OK
  datos.push_back(std::unique_ptr<int>(new int(10)); // OK porque es un Rvalue

  std::cout << *datos[0] << std::endl;
}

    如果将语法应用于move没有实现构造函数的对象会发生什么move？

    发生的情况是，如果未找到构造函数move，编译器将尝试调用构造函数副本。如果这也没有找到，则会发生编译时错误。

    换句话说，将语法move应用于未准备好的对象不应在功能和性能方面产生负面影响。

    解释完所有这些并返回到最初问题的代码：

    std::vector<int> func()
{
  std::vector<int> toReturn(1000000,5);
  return std::move(toReturn); // 1
}

int main()
{
  std::vector<int> datos = std::move(func()); // 2

  // operaciones varias
}

    很明显，在这两种情况下，语法的附加值都是 null，尽管1在编译器未在返回值中应用优化的极少数情况下，使用可能是必要的。

    • 11

  2. Eferion 的解释非常好，我想评论他的解释但我还是不能；但是，我想在您的解释中添加一些内容。

    从 C++11 开始，当编译器遇到 a 时return，它会将返回对象转换为 a，Rvalue;因此根据情况调用移动构造函数或赋值运算符。

    所以你不需要做

    ObjetoPesado func()
{
  ObjetoPesado obj;
  // ...
  return std::move(obj);
}

    来源：http ://cppactual.blogspot.com/2016/04/understanding-la-sintaxis-move.html

    • 1