关于c ++：将一个std :: vector追加到另一个stnd :: vector的最有效方法是什么？

What is the most efficient way to append one std::vector to the end of another?

假设v1是目标向量，v2需要附加到它的后面。

我现在正在做：

1 2	v1.reserve(v1.size() + v2.size()); copy(v2.begin(), v2.end(), back_inserter(v1));

这是最有效的方法吗？或者可以通过复制一块内存来完成？谢谢！

相关讨论

经过多次争论(以及马修姆和维林泰哈斯潘的合理评论)，我将把我的建议改为

1	v1.insert( v1.end(), v2.begin(), v2.end() );

我将保留以前的建议：

1 2	v1.reserve( v1.size() + v2.size() ); v1.insert( v1.end(), v2.begin(), v2.end() );

后一种方法有一些原因，尽管它们都不够强大：

无法保证将重新分配向量的大小——例如，如果总和大小为1025，则可能会根据实现情况重新分配到2048。对于reserve也没有这样的保证，但对于具体的实现，这可能是真的。如果寻找瓶颈的话，检查一下可能会很麻烦。
reserve表明我们的意图是明确的——在这种情况下优化可能更有效(reserve可以在一些顶级实现中准备缓存)。
此外，对于EDCOX1，0，我们有一个C++标准保证只会有一个重新分配，而EDCOX1×2可能会被低效地执行，并做一些重新分配(也可以用一个特定的实现来测试)。

相关讨论

保留很可能是不必要的，因为这可能由insert函数自动完成。
不能保证Reserve会准确分配您请求的存储量。唯一的保证是capacity()将大于等于您的请求。
@Villintehaspam——标准中也没有保证插入将不会进行多个重新分配而不是一个。但是，有一个准备金保证：It is guaranteed that no reallocation takes place during insertions that happen after a call to reserve() until the time when an insertion would make the size of the vector greater than the size specified in the most recent call to reserve().因此，准备金更安全。
@Kornel Kisilewicz：事实上，我相信在23.2.4.4项中或多或少有这样一个保证(对于普通迭代器)，其中复杂性被规定为范围[第一，最后]中元素数量加上到向量末端的距离的线性。多个重新分配不适合这个法案，除非我弄错了？
@维林泰斯帕姆：很重要——我可以把我的武器放在这个论点中，但不是最后一个——你假设一个重新分配需要O(n)个时间，如果一个向量被类似于一个"绳子"的实现，那么这可能是不正确的，因此是支离破碎的。我不知道有任何这样的实现，但它仍然遵循03标准(而不是1X标准，其中数据保证是连续的)。另外，我可以完全想象一个实现，其中保留是"精确的"，而"插入"重新分配不是。明确表达你的要求总是好的。
向量已经保证是连续的。您一定把它和std:：string混淆了。
@叔叔，是的，我的错。
这种保留似乎与GCC4.4和VC++2005都没有任何区别。我认为你也会把整件事和"推回"所使用的调整大小策略混淆在一起。(VC++为字符串分配的比请求的多-至少有小的值-以便请求大小为两个或两个左右的倍数的块，但在追加之前再次保留不会对结果的容量产生任何影响。将一个100个字符的字符串附加到一个100个字符的字符串后，将得到一个容量为207的字符串。)
另外，您应该确定哪个向量大于另一个向量，并将较小的向量插入较大的向量中；)
其次，由于您使用的是插入而不是复制，所以保留是无偿的…你不需要它。在引擎盖下面，insert可能要在一个块中执行reserve操作，而不是像copy()那样向后推。
@Ceretullis，现在的尺寸比较点很强，介意我把它包括在答案里吗？
如果它在概念上很重要，那么在什么后面附加什么呢？-另一个关于储备问题的思考是：这是否会增加维护负担？它基本上不增加任何价值，至少在一些常见的实现中是这样。但是，我可以想象，最终您可能希望将不同向量的内容全部附加在一起——现在，您可能最终会保留太少的内存分配，而改为保留两个内存分配。(不管怎样，我不信教。)
@ CeleTulLIS：这里的比较是无关紧要的，因为OP要求EDCOX1×1作为目标，EDOCX1 2附加到它。有时秩序很重要。此外，如果我要比较，我宁愿检查容量比大小，看看是否大到足以容纳所有的数据。如果你必须扩展一个的能力，你最终会复制这两个内容无论如何，副本的顺序并不重要…
@科内尔：我可能不会使用reserve和信任insert。此外，还存在着对复杂性的混淆。由于所采用的增长策略(通常为2*x+1)使push_back具有摊销不变的复杂性，因此即使有多次再分配，insert也具有摊销线性复杂性。请注意，如果插入的对象不是RandomAccessIterator，那么最好不要计算范围的长度，只计算push_back。我不知道他们是不是为random_access_iterator_tag做了特殊的案子。
@马修，叹气，你说服了我，我编辑了答案：>
@Matthieu：比较容量而不是尺寸的好方法。
@维林泰哈斯帕姆："多次重新分配不适合这个法案，除非我弄错了？"如果插入一个事物总是摊余常数，那么每次插入一个事物就是摊余常数*n=线性，即使可能有多个重新分配……8年后

可能更好更简单地使用专用方法：vector.insert

1	v1.insert(v1.end(), v2.begin(), v2.end());

正如Michael提到的，除非迭代器是输入迭代器，否则向量将计算出所需的大小，并以线性复杂性一次性复制附加的数据。

相关讨论

我只是用下面的代码做了一个快速的性能测量，

1	v1.insert( v1.end(), v2.begin(), v2.end() );

似乎是正确的选择(如上所述)。不过，您可以在下面找到报告的性能。

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#include <vector>
#include <string>

#include <boost/timer/timer.hpp>

//==============================================================================
//
//==============================================================================

/// Returns a vector containing the sequence [ 0, ... , n-1 ].
inline std::vector<int> _range(const int n)
{
std::vector<int> tmp(n);
for(int i=0; i<n; i++)
tmp[i] = i;
return tmp;
}

void test_perf_vector_append()
{
const vector<int> testdata1 = _range(100000000);
const vector<int> testdata2 = _range(100000000);

vector<int> testdata;

printf("--------------------------------------------------------------
");
printf(" METHOD: push_back()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;
for(size_t i=0; i<testdata2.size(); i++)
{
testdata.push_back(testdata2[i]);
}
}

printf("--------------------------------------------------------------
");
printf(" METHOD: reserve() + push_back()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;
testdata.reserve(testdata.size() + testdata2.size());
for(size_t i=0; i<testdata2.size(); i++)
{
testdata.push_back(testdata2[i]);
}
}

printf("--------------------------------------------------------------
");
printf(" METHOD: insert()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;

testdata.insert( testdata.end(), testdata2.begin(), testdata2.end() );
}

printf("--------------------------------------------------------------
");
printf(" METHOD: reserve() + insert()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;

testdata.reserve( testdata.size() + testdata.size() );
testdata.insert( testdata.end(), testdata2.begin(), testdata2.end() );
}

printf("--------------------------------------------------------------
");
printf(" METHOD: copy() + back_inserter()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;

testdata.reserve(testdata.size() + testdata2.size());
copy(testdata2.begin(), testdata2.end(), back_inserter(testdata));
}

printf("--------------------------------------------------------------
");
printf(" METHOD: reserve() + copy() + back_inserter()
");
printf("--------------------------------------------------------------
");
testdata.clear();
{ vector<int>().swap(testdata); }
testdata = testdata1;
{
boost::timer::auto_cpu_timer t;

testdata.reserve(testdata.size() + testdata2.size());
copy(testdata2.begin(), testdata2.end(), back_inserter(testdata));
}

}

对于Visual Studio 2008 SP1、X64、发布模式/O2/LTCG，输出如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

--------------------------------------------------------------
METHOD: push_back()
--------------------------------------------------------------
0.933077s wall, 0.577204s user + 0.343202s system = 0.920406s CPU (98.6%)

--------------------------------------------------------------
METHOD: reserve() + push_back()
--------------------------------------------------------------
0.612753s wall, 0.452403s user + 0.171601s system = 0.624004s CPU (101.8%)

--------------------------------------------------------------
METHOD: insert()
--------------------------------------------------------------
0.424065s wall, 0.280802s user + 0.140401s system = 0.421203s CPU (99.3%)

--------------------------------------------------------------
METHOD: reserve() + insert()
--------------------------------------------------------------
0.637081s wall, 0.421203s user + 0.218401s system = 0.639604s CPU (100.4%)

--------------------------------------------------------------
METHOD: copy() + back_inserter()
--------------------------------------------------------------
0.743658s wall, 0.639604s user + 0.109201s system = 0.748805s CPU (100.7%)

--------------------------------------------------------------
METHOD: reserve() + copy() + back_inserter()
--------------------------------------------------------------
0.748560s wall, 0.624004s user + 0.124801s system = 0.748805s CPU (100.0%)

相关讨论

如果您碰巧使用Boost，那么可以从Boost保管库下载Rangex库的开发版本。这个库。不久前就被接受为Boost，但到目前为止还没有与主发行版整合。在其中，您将发现一种新的基于范围的算法，它可以完全满足您的需要：

1	boost::push_back(v1, v2);

在内部，它的工作方式与Unclebens给出的答案类似，但代码更简洁易读。

如果您有一个pod类型的向量，并且您确实需要它的性能，那么您可以使用memcpy，它应该比vector<>.insert(…)：

1 2	v2.resize(v1.size() + v2.size()); memcpy((void)&v1.front(), (void)&v2[v1.size()], sizeof(v1.front())*v1.size());

更新：尽管我只会在性能确实需要的情况下使用它，但是代码对于pod类型是安全的。

相关讨论