blocks|key|1804879|text|是的，这对于交换相同类型的向量是非常安全的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1804880|引擎盖下的向量只是指向向量使用的数据和序列的“结束”的几个指针。调用交换时，只需在向量之间交换这些指针。你不需要担心向量的大小是一样的。|1804881|不同类型的向量不能使用swap交换。您需要实现自己的函数来进行转换和交换。|offset|length|style|CODE|1804882|entityMap^0|0|0|B|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Yes, this is perfectly safe to swap vectors of the same type.

Vector under the hood is just a few pointers pointing to the data the vector uses and "end" of the sequence. When you call swap you just exchange those pointers between the vectors. You don't need to worry that the vectors are the same size because of this.

Vectors of different types cannot be swapped using <code>swap</code>. You'd need to implement your own function that does the conversion and swapping.

blocks|key|1596287|text|在C%2B%2B中使用std::vector::swap方法交换两个不同的向量安全吗？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1596288|是。交换通常被认为是安全的。另一方面，安全又是主观的、相对的，可以从不同的角度来考虑。因此，如果不以上下文加强问题，并选择考虑何种安全措施，就不可能给出令人满意的答案。|unstyled|1596289|是否仍然可以安全地将这两个向量与std：：vector：：WidgetVector.swap方法(Widget2Vector)交换，还是会导致UB？|1596290|不会有UB的。是的，从某种意义上说，这个程序是不正确的，这仍然是安全的.|1596291|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|D|7|O|8|@]|9|@]|A|$]]]|J|$]]

<blockquote>
 Is it safe to swap two different vectors in C++, using the std::vector::swap method?
</blockquote>

Yes. Swapping can generally be considered safe. On the other hand, safety is subjective and relative and can be considered from different perspectives. As such, it is not possible to give a satisfactory answer without augmenting the question with a context, and choosing what sort of safety is being considered.

<blockquote>
 Is it still safe to swap the two vectors with the std::vector::swap method: WidgetVector.swap(Widget2Vector); or it will lead to an UB?
</blockquote>

There will not be UB. Yes, it is still safe in the sense that the program is ill-formed.

blocks|key|1804955|text|swap函数的定义如下：void+swap(+T&+a,+T&+b+);。请注意，a和b都是(而且必须是)相同类型的。(没有用以下签名定义的函数：void+swap(+T1&+a,+T2&+b+)，因为它没有任何意义！)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1804956|类似地，swap()类的std::vector成员函数定义如下：|1804957|template<class+T1>+class+vector+//+Note:+simplified+from+the+ACTUAL+STL+definition
{
//...
public:
++++void+swap(+vector&+other+);
//...
};|code-block|syntax|javascript|1804958|现在，由于函数参数(将为表单：函数模板的显式专门化)没有模板覆盖的“等效”定义(参见template+<typename+T2>+void+swap(std::vector<T2>&+other))，该参数必须是与“调用”类相同类型(模板)的向量(也必须是vector<T1>)。|1804959|std::vector<Widget>和std::vector<Widget2>是两种不同的类型，因此对swap的调用不会编译，无论您尝试使用任何对象的成员函数(就像代码一样)，还是使用以两个std:vector对象作为参数的std::swap()函数的专门化。|1804960|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/algorithm/swap|1|https://en.cppreference.com/w/cpp/language/template_specialization^0|0|4|C|O|15|1|17|1|21|P|1H|5|C|O|0|0|4|6|C|B|0|0|16|1K|3K|A|F|A|1|0|0|J|K|K|1G|4|2O|A|35|B|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|D]]|E|@$9|1E|A|1F|1|1G]]|F|$]]|$1|G|3|H|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1M|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|E|@$9|1S|A|1T|1|1U]]|F|$]]|$1|P|3|Q|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]]|E|@]|F|$]]|$1|R|3|-4|5|6|7|26|8|@]|E|@]|F|$]]]|S|$T|$5|U|V|W|F|$X|Y]]|Z|$5|U|V|W|F|$X|10]]]]

The <code>swap</code> function is defined as follows: <a href="https://en.cppreference.com/w/cpp/algorithm/swap" rel="nofollow noreferrer"><code>void swap( T&amp; a, T&amp; b );</code></a>. Note here that both <code>a</code> and <code>b</code> are (and have to be) the same type. (There is no such function defined with this signature: <code>void swap( T1&amp; a, T2&amp; b )</code>, as it would make no sense!)

Similarly, the <code>swap()</code> member function of the <code>std::vector</code> class is defined as follows:

<pre class="lang-cpp prettyprint-override"><code>template&lt;class T1&gt; class vector // Note: simplified from the ACTUAL STL definition
{
//...
public:
 void swap( vector&amp; other );
//...
};
</code></pre>

Now, as there is no 'equivalent' definition with a template override (see <a href="https://en.cppreference.com/w/cpp/language/template_specialization" rel="nofollow noreferrer">Explicit specializations of function templates</a>) for the function parameter (which would be of the form: <code>template &lt;typename T2&gt; void swap(std::vector&lt;T2&gt;&amp; other)</code>), that parameter must be a vector of the same type (template) as the 'calling' class (that is, it must also be a <code>vector&lt;T1&gt;</code>).

Your <code>std::vector&lt;Widget&gt;</code> and <code>std::vector&lt;Widget2&gt;</code> are two different types, so the call to <code>swap</code> won't compile, whether you try to use the member function of either object (as your code does), or using the specialization of the <code>std::swap()</code> function that takes two <code>std:vector</code> objects as parameters.

blocks|key|1596360|text|您不能交换两种不同类型的向量，但这是编译错误而不是UB。vector::swap只接受相同类型的向量和分配器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1596361|不确定这是否有效，但是如果您想要一个包含从Widget2转换而来的Widget的向量，您可以尝试如下：|1596362|std::vector<Widget2>+Widget2Vector(
++++std::make_move_iterator(WidgetVector.begin()),
++++std::make_move_iterator(WidgetVector.end())
);|code-block|syntax|javascript|1596363|Widget2必须从Widget中移出可构造的。|1596364|entityMap^0|S|C|0|L|7|X|6|0|0|0|7|A|6|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

You can't swap vectors of two different types but it's a compilation error instead of UB. <code>vector::swap</code> only accepts vectors of the same type and allocator.

Not sure if this will work, but if you want a vector containing <code>Widget2</code>s converted from <code>Widget</code>s you can try this:

<pre><code>std::vector&lt;Widget2&gt; Widget2Vector(
 std::make_move_iterator(WidgetVector.begin()),
 std::make_move_iterator(WidgetVector.end())
);
</code></pre>

<code>Widget2</code> will have to be move constructible from <code>Widget</code>.

blocks|key|1596406|text|它是安全的，因为在交换操作期间没有创建任何内容。只交换类std::vector的数据成员。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1596407|考虑下面的演示程序，它清楚地说明了类std::vector的对象是如何交换的。|1596408|#include+<iostream>
#include+<utility>
#include+<iterator>
#include+<algorithm>
#include+<numeric>

class+A
{
public:
++++explicit+A(+size_t+n+)+:+ptr(+new+int[n]()+),+n(+n+)
++++{
++++++++std::iota(+ptr,+ptr+%2B+n,+0+);+++
++++}

++++~A()+
++++{+
++++++++delete+[]ptr;+
++++}

++++void+swap(+A+&+a+)+noexcept
++++{
++++++++std::swap(+ptr,+a.ptr+);
++++++++std::swap(+n,+a.n+);
++++}

++++friend+std::ostream+&+operator+<<(+std::ostream+&os,+const+A+&a+)
++++{
++++++++std::copy(+a.ptr,+a.ptr+%2B+a.n,+std::ostream_iterator<int>(+os,+"+"+)+);
++++++++return+os;
++++}

private:++++
++++int+*ptr;
++++size_t+n;
};

int+main()+
{
++++A+a1(+10+);
++++A+a2(+5+);

++++std::cout+<<+a1+<<+'\n';
++++std::cout+<<+a2+<<+'\n';

++++std::cout+<<+'\n';

++++a1.swap(+a2+);

++++std::cout+<<+a1+<<+'\n';
++++std::cout+<<+a2+<<+'\n';

++++std::cout+<<+'\n';

++++return+0;
}|code-block|syntax|javascript|1596409|程序输出是|1596410|0+1+2+3+4+5+6+7+8+9+
0+1+2+3+4+

0+1+2+3+4+
0+1+2+3+4+5+6+7+8+9+|1596411|如您所见，在成员函数交换中只交换数据成员ptr和n。没有使用任何额外的资源。|1596412|在类std::vector中也使用了类似的方法。|1596413|至于这个例子|1596414|std::vector<Widget>+WidgetVector;

std::vector<Widget2>+Widget2Vector;|1596415|然后是不同类的对象。成员函数交换应用于相同类型的向量。|1596416|entityMap^0|S|B|0|I|B|0|0|0|0|K|3|O|1|0|2|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1J|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1L|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|11|$]]

It is safe because nothing is created during the swap operation. Only data members of the class <code>std::vector</code> are swapped.

Consider the following demonstrative program that makes it clear how objects of the class <code>std::vector</code> are swapped.

<pre><code>#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;numeric&gt;

class A
{
public:
 explicit A( size_t n ) : ptr( new int[n]() ), n( n )
 {
 std::iota( ptr, ptr + n, 0 ); 
 }

 ~A() 
 { 
 delete []ptr; 
 }

 void swap( A &amp; a ) noexcept
 {
 std::swap( ptr, a.ptr );
 std::swap( n, a.n );
 }

 friend std::ostream &amp; operator &lt;&lt;( std::ostream &amp;os, const A &amp;a )
 {
 std::copy( a.ptr, a.ptr + a.n, std::ostream_iterator&lt;int&gt;( os, " " ) );
 return os;
 }

private: 
 int *ptr;
 size_t n;
};

int main() 
{
 A a1( 10 );
 A a2( 5 );

 std::cout &lt;&lt; a1 &lt;&lt; '\n';
 std::cout &lt;&lt; a2 &lt;&lt; '\n';

 std::cout &lt;&lt; '\n';

 a1.swap( a2 );

 std::cout &lt;&lt; a1 &lt;&lt; '\n';
 std::cout &lt;&lt; a2 &lt;&lt; '\n';

 std::cout &lt;&lt; '\n';

 return 0;
}
</code></pre>

The program output is

<pre><code>0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 

0 1 2 3 4 
0 1 2 3 4 5 6 7 8 9 
</code></pre>

As you see only data members <code>ptr</code> and <code>n</code> are swapped in the member function swap. Neither additional resources are used.

A similar approach is used in the class <code>std::vector</code>.

As for this example

<pre><code>std::vector&lt;Widget&gt; WidgetVector;

std::vector&lt;Widget2&gt; Widget2Vector;
</code></pre>

then there are objects of different classes. The member function swap is applied to vectors of the same type.

blocks|key|961861|text|using+std::swap;+swap(a,+b);和a.swap(b);的语义与后者完全相同，至少对于任何正常的类型都是如此。在这方面，所有标准类型都是正常的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|961862|除非您使用有趣的分配器(意思是有状态的，不总是相等的，并且没有在容器交换上传播，请参阅std::allocator_traits)，否则使用相同的模板交换两个std::vector-参数只是三个值(容量、大小和数据指针)的无聊交换。并且交换基本类型，没有数据竞争，是安全的，不能抛出。|961863|标准甚至保证了这一点。见std::vector::swap()。|961864|entityMap|0|LINK|mutability|MUTABLE|url|//en.cppreference.com/w/cpp/memory/allocator_traits|1|//en.cppreference.com/w/cpp/container/vector|2|https://en.cppreference.com/w/cpp/container/vector/swap^0|0|S|T|A|0|17|L|27|B|17|L|0|27|B|1|0|C|J|C|J|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]]|E|$]]|$1|H|3|I|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|J|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]|T|$5|M|N|O|E|$P|U]]]]

<code>using std::swap; swap(a, b);</code> and <code>a.swap(b);</code> have the exact same semantics where the latter works; at least for any sane type. All standard types are sane in that regard.

Unless you use an interesting allocator (meaning stateful, not always equal, and not propagated on container swap, see <a href="//en.cppreference.com/w/cpp/memory/allocator_traits" rel="nofollow noreferrer"><code>std::allocator_traits</code></a>), swapping two <a href="//en.cppreference.com/w/cpp/container/vector" rel="nofollow noreferrer"><code>std::vector</code></a>s with the same template-arguments is just a boring swap of three values (for capacity, size, and data-pointer). And swapping basic types, absent data-races, is safe and cannot throw.

That is even guaranteed by the standard. See <a href="https://en.cppreference.com/w/cpp/container/vector/swap" rel="nofollow noreferrer"><code>std::vector::swap()</code></a>.

Suppose that you have the following code: 

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;

int main()
{
 std::vector&lt;std::string&gt; First{"example", "second" , "C++" , "Hello world" };
 std::vector&lt;std::string&gt; Second{"Hello"};

 First.swap(Second);

 for(auto a : Second) std::cout &lt;&lt; a &lt;&lt; "\n";
 return 0;
}
</code></pre>

Imagine the vector are not <code>std::string</code>, yet classes:

<pre><code>std::vector&lt;Widget&gt; WidgetVector;

std::vector&lt;Widget2&gt; Widget2Vector;
</code></pre>

Is it still safe to swap the two vectors with the <code>std::vector::swap</code> method: <code>WidgetVector.swap(Widget2Vector);</code> or it will lead to an UB?

Is it safe to swap two different vectors in C++, using the std::vector::swap method?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

假设您有以下代码：#include <iostream>#include <string>#include <vector>int main(){ std::vector<std::string> First{"example", "second" , "C++" , "Hello world" }; st...

问在C++中使用std::vector::swap方法交换两个不同的向量安全吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中使用std::vector::swap方法交换两个不同的向量安全吗？EN