将这个添加到头文件中:

template <typename T> vector<T> concat(vector<T> &a, vector<T> &b) {
    vector<T> ret = vector<T>();
    copy(a.begin(), a.end(), back_inserter(ret));
    copy(b.begin(), b.end(), back_inserter(ret));
    return ret;
}

然后这样用:

vector<int> a = vector<int>();
vector<int> b = vector<int>();

a.push_back(1);
a.push_back(2);
b.push_back(62);

vector<int> r = concat(a, b);

R将包含[1,2,62]

或者你可以用:

std::copy(source.begin(), source.end(), std::back_inserter(destination));

如果两个向量不包含完全相同类型的内容，则此模式非常有用，因为您可以使用某些内容而不是std::back_inserter来从一种类型转换为另一种类型。

对于range v3，你可能会有一个惰性连接:

ranges::view::concat(v1, v2)

演示。

如果您的目标只是为了只读目的而在值的范围内迭代，另一种替代方法是将两个向量围绕一个代理(O(1))而不是复制它们(O(n))，这样它们就会立即被视为单个连续的向量。

std::vector<int> A{ 1, 2, 3, 4, 5};
std::vector<int> B{ 10, 20, 30 };

VecProxy<int> AB(A, B);  // ----> O(1)!

for (size_t i = 0; i < AB.size(); i++)
    std::cout << AB[i] << " ";  // ----> 1 2 3 4 5 10 20 30

请参阅https://stackoverflow.com/a/55838758/2379625了解更多细节，包括“VecProxy”实现以及优缺点。

如果希望能够简洁地连接向量，可以重载+=运算符。

template <typename T>
std::vector<T>& operator +=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    vector1.insert(vector1.end(), vector2.begin(), vector2.end());
    return vector1;
}

然后你可以这样调用它:

vector1 += vector2;

如果你正在寻找的是在创建后将一个向量附加到另一个向量的方法，vector::insert是你最好的选择，因为已经回答了几次，例如:

vector<int> first = {13};
const vector<int> second = {42};

first.insert(first.end(), second.cbegin(), second.cend());

遗憾的是，没有办法构造一个const vector<int>，就像上面那样，你必须先构造然后插入。

如果你实际上是在寻找一个容器来保存这两个vector<int>s的连接，可能有更好的可用的东西给你，如果:

你的向量包含原语 包含的原语的大小为32位或更小 你需要一个const容器

如果以上都是正确的，我建议使用basic_string，它的char_type匹配vector中包含的原语的大小。你应该在你的代码中包含一个static_assert来验证这些大小保持一致:

static_assert(sizeof(char32_t) == sizeof(int));

有了这一点，你可以这样做:

const u32string concatenation = u32string(first.cbegin(), first.cend()) + u32string(second.cbegin(), second.cend());

要了解更多关于string和vector之间区别的信息，您可以查看这里:https://stackoverflow.com/a/35558008/2642059

有关此代码的实际示例，您可以在这里查看:http://ideone.com/7Iww3I