是否可以在C++中移动临时对象的属性?

Can I move attributes of temporary objects in C++?

本文关键字：临时对象 属性 移动 C++ 是否      更新时间：2023-10-16

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

struct Iter
{
int i = 0;
vector<int> vec;
Iter(const vector<int>& _vec):
vec(_vec)
{
cout << "copied vector of size "<<vec.size()<<" for iteratorn";
}
Iter(vector<int>&& _vec):
vec(move(_vec))
{
cout << "moved vector of size "<<vec.size()<<" for iteratorn";
}
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 factoryn";
}
Factory(vector<int>&& _v):
fac_vec(move(_v))
{
cout << "moved vector of size "<<fac_vec.size()<<" for factoryn";
}
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的移动构造函数，因为工厂在之后立即被摧毁(不是吗？(，并且编译器拥有决定这一点所需的所有信息。

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

通常，在实现迭代器时，您需要获取向量的迭代器或对向量的引用：

struct Iter
{
int i = 0;
vector<int>* vec;
Iter(vector<int>& _vec):
vec(&_vec)
{
cout << "copied vector of size "<<vec->size()<<" for iteratorn";
}
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，因为它是向量的左值。这里没有动静。您需要向量的右值才能移动它。

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

struct Factory
{
vector<int> fac_vec;
Factory(const vector<int>& _v):
fac_vec(_v)
{
cout << "copied vector of size " << fac_vec.size() << " for factoryn";
}
Factory(vector<int>&& _v):
fac_vec(move(_v))
{
cout << "moved vector of size "<<fac_vec.size()<<" for factoryn";
}
// 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。

的范围大致等效于：

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 &&

如果要在不推荐的迭代器中使用值，则不能使用范围 for 循环，并且必须使用旧样式的 for 循环。

请记住，像这样的调用通常被重新保护为代码气味，并且多次使用 move 更是如此。

相关文章：