blocks|key|142959|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|142960|在这个例子中，默认拷贝和std::move有什么区别？|blockquote|142961|142962|142963|这是没有区别的。复制满足move的要求，在内置类型的情况下，move实现为copy。|142964|142965|移动对象后，新旧之间是否存在依赖关系|142966|142967|142968|不，没有依赖项。这两个变量是独立的。|142969|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|T|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|U|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|V|7|@]|8|@]|9|$]]|$1|I|3|J|4|C|6|W|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|Y|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|Z|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|10|7|@]|8|@]|9|$]]]|P|$]]

<blockquote>
 What's difference between default copy and std::move in that example?
</blockquote>

There is no difference. Copying something satisfies the requirements of a move, and in the case of built-in types, move is implemented as a copy.

<blockquote>
 After move the object is there any dependence between new and old
</blockquote>

No, there are no dependencies. Both variables are independent.

blocks|key|2928775|text|在这个例子中，没有区别。我们最终将得到3个值为100的int。不过，不同的类型肯定会有所不同。例如，让我们考虑像vector<int>这样的东西|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2928776|std::vector<int>+a+=+{1,+2,+3,+4,+5};+//+a+has+size+5
auto+a_copy+=+a;++++++++++++++++++++++//+copy+a.+now+we+have+two+vectors+of+size+5
auto+a_move+=+std::move(a);+++++++++++//+*move*+a+into+a_move|code-block|syntax|javascript|2928777|最后一个变量a_move获得了a内部指针的所有权。所以我们最终得到的是a_move是一个大小为5的向量，但a现在是空的。move比copy效率高得多(想象一下，如果它是一个1000个字符串的向量-+a_copy需要分配1000个字符串的缓冲区和复制1000个字符串，但a_move只分配了几个指针)。|2928778|对于其他一些类型，其中一个可能是无效的：|2928779|std::unique_ptr<int>+a{new+int+42};
auto+a_copy+=+a;++++++++++++//+error
auto+a_move+=+std::move(a);+//+OK,+now+a_move+owns+42,+but+a+points+to+nothing|2928780|但对于许多类型，没有区别：|2928781|std::array<int,+100>+a;
auto+a_copy+=+a;++++++++++++//+copy+100+ints
auto+a_move+=+std::move(a);+//+also+copy+100+ints,+no+special+move+ctor|2928782|更一般地说：|2928783|T+a;
auto+a_copy+=+a;++++++++++++//+calls+T(const+T&+),+the+copy+constructor
auto+a_move+=+std::move(a);+//+calls+T(T&&+),+the+move+constructor|2928784|entityMap^0|R|3|1K|B|0|0|6|6|F|1|Z|6|1H|1|1O|4|1T|4|2R|6|3Q|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1N|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1R|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|Y|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|Z|$]]

In this example, there is no difference. We will end up with 3 <code>int</code>s with value 100. There could definitely be a difference with different types though. For instance, let's consider something like <code>vector&lt;int&gt;</code>:

<pre><code>std::vector&lt;int&gt; a = {1, 2, 3, 4, 5}; // a has size 5
auto a_copy = a; // copy a. now we have two vectors of size 5
auto a_move = std::move(a); // *move* a into a_move
</code></pre>

The last variable, <code>a_move</code>, takes ownership of <code>a</code>'s internal pointers. So what we end up with is <code>a_move</code> is a vector of size 5, but <code>a</code> is now empty. The <code>move</code> is much more efficient than a <code>copy</code> (imagine if it was a vector of 1000 strings instead - <code>a_copy</code> would involve allocating a 1000-string buffer and copying 1000 strings, but <code>a_move</code> just assigns a couple pointers). 

For some other types, one might be invalid:

<pre><code>std::unique_ptr&lt;int&gt; a{new int 42};
auto a_copy = a; // error
auto a_move = std::move(a); // OK, now a_move owns 42, but a points to nothing
</code></pre>

For many types, there's no difference though:

<pre><code>std::array&lt;int, 100&gt; a;
auto a_copy = a; // copy 100 ints
auto a_move = std::move(a); // also copy 100 ints, no special move ctor
</code></pre>

More generally:

<pre><code>T a;
auto a_copy = a; // calls T(const T&amp; ), the copy constructor
auto a_move = std::move(a); // calls T(T&amp;&amp; ), the move constructor
</code></pre>

blocks|key|2716050|text|使用std::move只是将左值更改为x值，因此它有资格与移动构造函数和移动赋值操作符一起使用。这些对于内置类型是不存在的，所以在本例中使用move没有区别。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2716051|entityMap^0|2|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Using <code>std::move</code> just changes an lvalue to an xvalue, so it is eligible for use with move constructors and move assignment operators. These do not exist for built-in types, so using move makes no difference in this example.

blocks|key|144341|text|为了扩展另一个发帖者的答案，move-is-a-copy范例也适用于由POD类型组成的所有数据结构(或由POD类型组成的其他类型组成)，如下例所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|144342|struct+Foo
{
++++int+values[100];
++++bool+flagA;
++++bool+flagB;
};

struct+Bar
{
++++Foo+foo1;
++++Foo+foo2;
};

int+main()
{
++++Foo+f;
++++Foo+fCopy+=+std::move(f);
++++Bar+b;
++++Bar+bCopy+=+std::move(b);
++++return+0;
}|code-block|syntax|javascript|144343|在Foo和Bar的情况下，没有任何有意义的方法将数据从一个移动到另一个，因为两者最终都是POD类型的聚合-它们的数据都不是间接拥有的(指向或引用其他内存)。因此，在这些情况下，移动是作为副本实现的，原始(f，b)在std::move()行上的赋值后保持不变。|offset|length|style|CODE|144344|移动语义只能通过动态分配的内存或唯一资源来有意义地实现。|144345|entityMap^0|0|0|1|3|5|3|2U|1|2W|1|2Z|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

To expand on the other poster's answer, the move-is-a-copy paradigm applies to all data structures composed of POD types (or composed of other types composed of POD types) as well, as in this example:

<pre><code>struct Foo
{
 int values[100];
 bool flagA;
 bool flagB;
};

struct Bar
{
 Foo foo1;
 Foo foo2;
};

int main()
{
 Foo f;
 Foo fCopy = std::move(f);
 Bar b;
 Bar bCopy = std::move(b);
 return 0;
}
</code></pre>

In the case of both <code>Foo</code> and <code>Bar</code> there is no meaningful way to move the data from one to another because both are ultimately aggregates of POD types - none of their data is indirectly owned (points to or references other memory). So in these cases, the move is implemented as a copy and originals (<code>f</code>, <code>b</code>) remain unaltered after the assignments on the <code>std::move()</code> lines.

Move semantics can only be meaningfully implemented with dynamically allocated memory or unique resources.

<ul>
<li>What's difference between default copy and std::move in that example?</li>
<li>After <code>move</code> the object is there any dependence between new and old ones?</li>
</ul>



<pre><code>int main () {

 int a = 100;
 std::cout&lt;&lt;&amp;a&lt;&lt;std::endl;

 auto a_copy = a; // deduced as int
 std::cout&lt;&lt;&amp;a_copy&lt;&lt;std::endl;

 auto a_move = std::move(a); // deduced as int
 std::cout&lt;&lt;&amp;a_move&lt;&lt;std::endl;

};
</code></pre>

output:

<pre><code>0x7fffffffe094
0x7fffffffe098
0x7fffffffe09c
</code></pre>

copy vs std::move for ints

数据结构

在示例中，default copy和std::move有什么区别？在move对象之后，新旧对象之间有依赖关系吗？int main () { int a = 100; std::cout<<&a<<std::endl; auto a_copy = a; // deduce...

问copy vs std::move for int
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问copy vs std::move for intEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问copy vs std::move for int
EN