Question

当我运行下面的代码时，它产生以下输出，第一部分直接使用模板，第二个使用从模板派生的类。在派生类中没有调用移动语义（以粗体显示）

模板虚拟：初始化构造函数
模板虚拟：初始化构造函数
模板虚拟：空构造函数
模板虚拟：空构造函数
模板虚拟：+操作员
模板虚拟：移动作业
2

模板虚拟：初始化构造函数
模板虚拟：初始化构造函数
模板虚拟：空构造函数
模板虚拟：空构造函数
模板虚拟：+操作员
模板虚拟：复制构造函数
模板虚拟：复制作业
2个

我认为原因很明显 - 命名参数会将参数转换为左值，因此模板会接收左值并调用复制构造函数。

问题是在这种情况下如何强制移动语义？

  #include <iostream>

  using namespace std;

  template <typename T> class Dummy {

  public:

    T val;

    Dummy& operator=(const Dummy& d){
      val = d.val;
      cout << "Template Dummy: copy assignment\n" ;
      return *this;
    }

    Dummy operator+(const Dummy &d) {
      Dummy res;
      res.val = val + d.val;
      cout << "Template Dummy: +  operator\n" ;
      return res;
    }

    // constructors
    Dummy() {
      val = 0;
      cout << "Template Dummy: empty constructor\n" ;
    }

    Dummy(const T v) {
      val = v;
      cout << "Template Dummy: initializing constructor\n" ;
    }

    Dummy(const Dummy &d) {
      val = d.val;
      cout << "Template Dummy: copy constructor\n" ;
    }

    // move semantics
    Dummy(const Dummy&& d) {
      val = d.val;
      cout << "Template Dummy: move constructor\n" ;
    }

    Dummy& operator=(const Dummy&& d){
      val = d.val;
      cout << "Template Dummy: move assignment\n" ;
      return *this;
    }
  };

  class FloatDummy : public Dummy<float> {
  public:

      FloatDummy& operator=(const FloatDummy& d){
        Dummy<float>::operator=(d);
        return *this;
      }

      FloatDummy operator+(const FloatDummy &d) {
        return (FloatDummy) Dummy<float>::operator+(d);
      }

      // constructors
      FloatDummy() : Dummy<float>() {};
      FloatDummy(float v) : Dummy<float>(v) {}
      FloatDummy(const FloatDummy &d) : Dummy<float>(d) {}
      FloatDummy(const Dummy<float> &d) : Dummy<float>(d) {}

      // move semantics
      FloatDummy(const FloatDummy&& d) : Dummy<float>(d) {}

      FloatDummy& operator=(const FloatDummy&& d){

      // here d is already an lvalue because it was named
      // thus the template invokes a copy assignment    
      Dummy<float>::operator=(d);
      return *this;
    }
  };

  int main() {
    Dummy<float> a(1), b(1);
    Dummy<float> c;
    c = a + b;
    cout << c.val << '\n';;

    FloatDummy d(1), e(1);
    FloatDummy f;
    f = d + e;
    cout << f.val << '\n';
  }

Answer 1

您无法从const&移动。要解决此问题，只需从所有移动操作中删除const：

FloatDummy(FloatDummy&& d) : Dummy<float>(d) {}
//         ^^^^^^^^^^^^ no longer FloatDummy const&&

FloatDummy& operator=(FloatDummy&& d) { /*...*/ }
//                    ^^^^^^^^^^^^ ditto

移动的本质是获取资源的所有权如果你无法修改你的资源，你怎么能取得某些东西的所有权？因此，默认情况下，移动操作不适用于const类型。

您希望对Dummy类做同样的事情。

您需要调用std::move()将d转换为右值引用：尽管d的参数类型是右值引用，但在函数内部{{1}几乎被认为是左值引用。这意味着当你将它传递给实际消耗它的任何东西时，你仍然需要将它转换为右值引用（d的整点）。

在您的情况下，当您将其传递给std::move()的构造函数或Dummy<float>时，它是正确的：

Dummy<float>::operator=

如何在继承模板类

1 个答案: