我可以在 C++ 中移动临时对象的属性吗？

Question

我正在编写一个依赖于向量中的项目的迭代器和一个生成上述迭代器的迭代器工厂。该代码在概念上等同于以下内容：

struct Iter
{
  int i = 0;
  vector<int> vec;

  Iter(const vector<int>& _vec):
    vec(_vec)
  {
    cout << "copied vector of size "<<vec.size()<<" for iterator\n";
  }

  Iter(vector<int>&& _vec):
    vec(move(_vec))
  {
    cout << "moved vector of size "<<vec.size()<<" for iterator\n";
  }

  int& operator*() { return vec[i]; }
  Iter& operator++() { ++i; return *this; }
  bool operator!=(const Iter& _it) const { return false; }
};

struct Factory
{
  vector<int> fac_vec;

  Factory(const vector<int>& _v):
    fac_vec(_v)
  {
    cout << "copied vector of size " << fac_vec.size() << " for factory\n";
  }

  Factory(vector<int>&& _v):
    fac_vec(move(_v))
  {
    cout << "moved vector of size "<<fac_vec.size()<<" for factory\n";
  }

  Iter begin() { return Iter(fac_vec); }
  Iter end() { return Iter({}); }
};

int main(){
  for(const int i: Factory({1,2,3}))
    cout << i << "\n";
  return 0;
}

现在，运行这段代码给了我 (g++ 8.3)：

moved vector of size 3 for factory   [ initialization of the factory with {1,2,3} - moved ]
copied vector of size 3 for iterator [ initialization of the begin-iterator with fac_vec - copied ]
moved vector of size 0 for iterator  [ initialization of the end-iterator with {} - moved ]

这有点令人失望，因为我希望最后一个 begin() 会调用 Iter 的 move-constructor，因为工厂在之后立即被销毁（不是吗？）并且编译器拥有所有信息它需要决定这一点。

我想我可以使用std::shared_ptr 做我想做的事，但这会在代码和程序中产生开销。当最后一个 begin() 被调用时，我宁愿告诉编译器 move fac_vec。有没有办法做到这一点？

Answer 1

通常，在实现迭代器时，您采用向量的迭代器或对向量的引用：

struct Iter
{
  int i = 0;
  vector<int>* vec;

  Iter(vector<int>& _vec):
    vec(&_vec)
  {
    cout << "copied vector of size "<<vec->size()<<" for iterator\n";
  }

  int& operator*() { return (*vec)[i]; }
  Iter& operator++() { ++i; return *this; }
  bool operator!=(const Iter& _it) const { return false; }
};

这样你永远不会复制。

更好，使用vector自己的迭代器：

struct Iter
{
  vector<int>::iterator it;

  Iter(vector<int>::iterator _it):
    it(_it)
  { }

  int& operator*() { return *it; }
  Iter& operator++() { ++it; return *this; }
  bool operator!=(const Iter& _it) const { return false; }
};

但是，您可以删除 Iter 并简单地使用向量迭代器：

struct Factory
{
  // ...    

  auto begin() { return fac_vec.begin(); }
  auto end() { return fac_vec.end(); }
};

---

现在如果你真的想在迭代器中包含一个值（不推荐）。

编译器不会移动fac_vec，因为它是向量的左值。这里不动。你需要一个向量的右值来移动它。

您可以通过重载右值引用实例的函数来获得：

struct Factory
{
  vector<int> fac_vec;

  Factory(const vector<int>& _v):
    fac_vec(_v)
  {
    cout << "copied vector of size " << fac_vec.size() << " for factory\n";
  }

  Factory(vector<int>&& _v):
    fac_vec(move(_v))
  {
    cout << "moved vector of size "<<fac_vec.size()<<" for factory\n";
  }

  // moving  when Factory is temporary
  Iter begin() && { return Iter(std::move(fac_vec)); }
  Iter end() && { return Iter({}); }

  // copying
  Iter begin() const& { return Iter(fac_vec); }
  Iter end() const& { return Iter({}); }
};

但是 for 循环不会调用 move 版本。为什么？这会很危险，因为这需要在一个类型上多次调用 move。

一个范围大致相当于：

auto&& range = <range expr>; // forwarding reference to range (rvalue in your case)
auto begin = range.begin(); // range is lvalue, so calls the const&
auto end = range.end(); // range is lvalue, so calls the const&

for (/* ... */) {
    // body
}

要使用您的移动操作，需要多次将范围转换为右值，可能使用移动的值：

auto begin = std::move(range).begin(); // range is lvalue but moved so calls the &&
auto end = std::move(range).end(); // range is lvalue but moved so calls the &&

如果要在不推荐的迭代器中使用 value，则不能使用 range for 循环，必须使用旧式 for 循环。

请记住，像这样的 move 调用通常会被视为代码异味，而多次使用 move 更是如此。