blocks|key|100986|text|当您需要将对象的内容“传输”到其他地方时，可以使用move，而不需要复制。对象也可以不使用std::move来获取临时对象的内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|100987|从维基百科了解更多关于Rvalue引用和移动构造函数的信息。|offset|length|100988|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C%2B%2B11#Rvalue_references_and_move_constructors^0|0|B|F|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You can use move when you need to &quot;transfer&quot; the content of an object somewhere else, without doing a copy. It's also possible for an object to take the content of a temporary object without doing a copy, with std::move.
Read more on <a href="http://en.wikipedia.org/wiki/C++11#Rvalue_references_and_move_constructors" rel="nofollow noreferrer">Rvalue references and move constructors</a> from wikipedia.

blocks|key|2210720|text|当您有一个T&&类型的对象(+rvalue+)时，这意味着这个对象可以安全地被移动，因为以后没有人会依赖于它的内部状态。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2210721|因为移动不应该比复制更昂贵，你几乎总是想要移动它。要移动它，必须使用std::move函数。|2210722|您什么时候应该避免std::move，即使它是安全的？我不会在一些琐碎的例子中使用它，例如：|2210723|+int+x+=+0;
+int+y+=+std::move(x);|code-block|syntax|javascript|2210724|除此之外，我看不出有什么坏处。如果不使代码复杂化，则应该尽可能地移动IMHO。|2210725|另一个例子，您不想移动的是返回值。该语言保证返回值被移动(至少)，因此不应该编写|2210726|return+std::move(x);+//+not+recommended|2210727|(如果你幸运的话，返回值优化点击，这比移动操作还要好。)|2210728|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Return_value_optimization^0|5|3|0|Y|9|0|9|9|0|0|0|0|0|9|5|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1D|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|T|5|L|7|1G|8|@]|D|@]|E|$M|N]]|$1|U|3|V|5|6|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|W|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

When you have an object of type <code>T&amp;&amp;</code>, a rvalue, it means that this object is safe to be moved, as no one else will depend on its internal state later.

As moving should never be more expensive than copying, you will almost always want to move it. And to move it, you have to use the <code>std::move</code> function.

When should you avoid <code>std::move</code>, even if it would be safe? I wouldn't use it in trivial examples, e.g.,:

<pre><code> int x = 0;
 int y = std::move(x);
</code></pre>

Beside that, I see no downsides. If it does not complicate the code, moving should be done whenever possible IMHO.

Another example, where you don't want to move are return values. The language guarantees that return values are (at least) moved, so you should not write

<pre><code>return std::move(x); // not recommended
</code></pre>

(If you are lucky, <a href="https://en.wikipedia.org/wiki/Return_value_optimization" rel="nofollow">return value optimization</a> hits, which is even better than a move operation.)

blocks|key|1420561|text|我发现这篇文章在rvalue引用这一主题上非常有启发性。他最后提到了std::move。这可能是最相关的一句话：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1420562|我们需要使用std::move，来自<utility>+--+std::move是一种表达方式，“老实说，我知道我有一个lvalue，但我希望它是一个rvalue。”std::move本身不会移动任何东西；它只是将lvalue转化为rvalue，这样您就可以调用移动构造函数了。|blockquote|1420563|假设您有一个如下所示的move构造函数：|1420564|MyClass::MyClass(MyClass&&+other):+myMember(other.myMember)
{
++++//+Whatever+else.
}|code-block|syntax|javascript|1420565|当您使用语句other.myMember时，返回的值是lvalue。因此，代码使用复制构造函数初始化this->myMember。但是，由于这是一个移动构造函数，我们知道other是一个临时对象，因此它的成员也是如此。因此，我们非常希望使用更高效的移动构造函数来初始化this->myMember。使用std::move可以确保编译器将other.myMember视为rvalue引用，并按您的要求调用移动构造函数：|1420566|MyClass::MyClass(MyClass&&+other):+myMember(std::move(other.myMember))
{
++++//+Whatever+else.
}|1420567|只是不要在您需要保留的对象上使用std::move+--移动构造函数几乎可以保证会破坏传递给它们的任何对象。这就是为什么他们只和临时人员一起使用。|1420568|希望这能帮上忙！|1420569|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cprogramming.com/c%2B%2B11/rvalue-references-and-move-semantics-in-c%2B%2B11.html^0|Y|9|3|4|0|0|6|9|I|9|V|9|2B|9|0|0|0|6|E|1E|E|2D|5|3Q|E|47|9|4O|E|0|0|G|9|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|F|3|G|5|H|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1K|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|1L|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|R|3|S|5|M|7|1Z|8|@]|D|@]|E|$N|O]]|$1|T|3|U|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|23|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

I found <a href="http://www.cprogramming.com/c++11/rvalue-references-and-move-semantics-in-c++11.html" rel="noreferrer">this article</a> to be pretty enlightening on the subject of rvalue references in general. He mentions <code>std::move</code> towards the end. This is probably the most relevant quote:

<blockquote>
 We need to use <code>std::move</code>, from <code>&lt;utility&gt;</code> -- <code>std::move</code> is a way of
 saying, "ok, honest to God I know I have an lvalue, but I want it to
 be an rvalue." <code>std::move</code> does not, in and of itself, move anything; it
 just turns an lvalue into an rvalue, so that you can invoke the move
 constructor.
</blockquote>

<hr>

Say you have a move constructor that looks like this:

<pre><code>MyClass::MyClass(MyClass&amp;&amp; other): myMember(other.myMember)
{
 // Whatever else.
}
</code></pre>

When you use the statement <code>other.myMember</code>, the value that's returned is an lvalue. Thus the code uses the copy constructor to initialize <code>this-&gt;myMember</code>. But since this is a move constructor, we know that <code>other</code> is a temporary object, and therefore so are its members. So we really want to use the more-efficient move constructor to initialize <code>this-&gt;myMember</code>. Using <code>std::move</code> makes sure that the compiler treats <code>other.myMember</code> like an rvalue reference and calls the move constructor, as you'd want it to:

<pre><code>MyClass::MyClass(MyClass&amp;&amp; other): myMember(std::move(other.myMember))
{
 // Whatever else.
}
</code></pre>

Just don't use <code>std::move</code> on objects you need to keep around - move constructors are pretty much guaranteed to muck up any objects passed into them. That's why they're only used with temporaries.

Hope that helps!

<blockquote>
 Possible Duplicate: 
 <a href="https://stackoverflow.com/q/3106110">What is move semantics?</a>
</blockquote>



I recently attended a C++11 seminar and the following tidbit of advice was given.

<pre><code>when you have &amp;&amp; and you are unsure, you will almost always use std::move
</code></pre>

Could any one explain to me why you should use <code>std::move</code> as opposed to some alternatives and some cases when you should not use <code>std::move</code>?

Why do you use std::move when you have && in C++11?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

可能重复：我最近参加了一个C++11研讨会，并给出了以下一些建议。when you have && and you are unsure, you will almost always use std::move有谁能向我解释一下为什么你应该使用std::move而不是一些替代方案，有些情况下你不应该使用std::mo...

问为什么在有&&在C++11中使用std::move？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在有&&在C++11中使用std::move？EN