我正在使用多线程并希望合并结果。例如：
std::vector<int> A;
std::vector<int> B;
std::vector<int> AB;
我希望 AB 必须按顺序访问 A 的内容和 B 的内容。做这样的事情最有效的方法是什么？
【问题讨论】：
如果您的向量已排序*，请查看 set_union 和 <algorithm>。
set_union(A.begin(), A.end(), B.begin(), B.end(), AB.begin());
链接中有一个更详尽的示例。
【讨论】：
AB.reserve( A.size() + B.size() ); // preallocate memory
AB.insert( AB.end(), A.begin(), A.end() );
AB.insert( AB.end(), B.begin(), B.end() );
【讨论】：
这正是成员函数std::vector::insert的用途
std::vector<int> AB = A;
AB.insert(AB.end(), B.begin(), B.end());
【讨论】：
insert 专门用于随机访问迭代器并预先保留，我不会感到惊讶。
distance 具有 O(1) 复杂度）。尽管如此，insert 的性能保证是需要注意的，因为您通常可以通过提前计划做得更好。
size < capacity 在大多数情况下，分支预测可能会导致非重新分配分支的指令位于指令流水线中，从而最大限度地减少分支引起的延迟（除了低迭代次数外）。这假设了一个好的向量实现，加上 CPU 指令管道和 [好的] 分支预测，但对于现代工具链和台式机来说，这些都是非常可靠的假设。虽然不知道智能手机..
取决于您是否真的需要将两个向量物理连接起来，或者您想要给出连接的外观以进行迭代。 boost::join 函数
http://www.boost.org/doc/libs/1_43_0/libs/range/doc/html/range/reference/utilities/join.html
会给你这个。
std::vector<int> v0;
v0.push_back(1);
v0.push_back(2);
v0.push_back(3);
std::vector<int> v1;
v1.push_back(4);
v1.push_back(5);
v1.push_back(6);
...
BOOST_FOREACH(const int & i, boost::join(v0, v1)){
cout << i << endl;
}
应该给你
1
2
3
4
5
6
注意 boost::join 不会将两个向量复制到新容器中 但会生成一对覆盖范围的迭代器（范围） 两个容器。会有一些性能开销，但也许 不如先将所有数据复制到新容器中。
【讨论】：
基于Kiril V. Lyadvinsky answer，我做了一个新版本。这个 sn -p 使用模板和重载。有了它，你可以写vector3 = vector1 + vector2 和vector4 += vector3。希望对您有所帮助。
template <typename T>
std::vector<T> operator+(const std::vector<T> &A, const std::vector<T> &B)
{
std::vector<T> AB;
AB.reserve(A.size() + B.size()); // preallocate memory
AB.insert(AB.end(), A.begin(), A.end()); // add A;
AB.insert(AB.end(), B.begin(), B.end()); // add B;
return AB;
}
template <typename T>
std::vector<T> &operator+=(std::vector<T> &A, const std::vector<T> &B)
{
A.reserve(A.size() + B.size()); // preallocate memory without erase original data
A.insert(A.end(), B.begin(), B.end()); // add B;
return A; // here A could be named AB
}
【讨论】：
:: 被占用了；）
v1 + v2不代表加法。
@，就像在 F# 中一样
所有解决方案都是正确的，但我发现编写一个函数来实现它更容易。像这样：
template <class T1, class T2>
void ContainerInsert(T1 t1, T2 t2)
{
t1->insert(t1->end(), t2->begin(), t2->end());
}
这样你就可以避免这样的临时放置：
ContainerInsert(vec, GetSomeVector());
【讨论】：
还有一个尚未提及的简单变体：
copy(A.begin(),A.end(),std::back_inserter(AB));
copy(B.begin(),B.end(),std::back_inserter(AB));
并使用合并算法：
#include <algorithm>
#include <vector>
#include <iterator>
#include <iostream>
#include <sstream>
#include <string>
template<template<typename, typename...> class Container, class T>
std::string toString(const Container<T>& v)
{
std::stringstream ss;
std::copy(v.begin(), v.end(), std::ostream_iterator<T>(ss, ""));
return ss.str();
};
int main()
{
std::vector<int> A(10);
std::vector<int> B(5); //zero filled
std::vector<int> AB(15);
std::for_each(A.begin(), A.end(),
[](int& f)->void
{
f = rand() % 100;
});
std::cout << "before merge: " << toString(A) << "\n";
std::cout << "before merge: " << toString(B) << "\n";
merge(B.begin(),B.end(), begin(A), end(A), AB.begin(), [](int&,int&)->bool {});
std::cout << "after merge: " << toString(AB) << "\n";
return 1;
}
【讨论】：
按照 Bradgonesurfing 的回答，很多时候并不真正需要连接两个向量 (O(n))，而只是 像连接它们一样使用它们(O(1))。如果这是您的情况，则无需 Boost 库即可完成。
诀窍是创建一个向量代理：一个包装类，它操作两个向量的引用，在外部被视为一个单独的连续向量。
用法
std::vector<int> A{ 1, 2, 3, 4, 5};
std::vector<int> B{ 10, 20, 30 };
VecProxy<int> AB(A, B); // ----> O(1). No copies performed.
for (size_t i = 0; i < AB.size(); ++i)
std::cout << AB[i] << " "; // 1 2 3 4 5 10 20 30
实施
template <class T>
class VecProxy {
private:
std::vector<T>& v1, v2;
public:
VecProxy(std::vector<T>& ref1, std::vector<T>& ref2) : v1(ref1), v2(ref2) {}
const T& operator[](const size_t& i) const;
const size_t size() const;
};
template <class T>
const T& VecProxy<T>::operator[](const size_t& i) const{
return (i < v1.size()) ? v1[i] : v2[i - v1.size()];
};
template <class T>
const size_t VecProxy<T>::size() const { return v1.size() + v2.size(); };
主要好处
创建它的时间为 O(1)（恒定时间），并且额外的内存分配最少。
需要考虑的一些事项
【讨论】：