How to Concatenate Two std::vector Objects in C++

By the end of this page, you will understand how to concatenate two std::vector objects in C++, when to use insert, how to avoid unnecessary copies, and what common mistakes to watch for when combining vectors.

std::vector is a dynamic array in C++ that stores elements in contiguous memory. Concatenating two vectors means taking all elements from one vector and appending them to the end of another.

In C++, there is no built-in + operator for std::vector in the standard library. Instead, developers usually concatenate vectors by using member functions such as insert.

This matters because concatenating collections is very common in real programs:

• merging results from multiple functions
• combining filtered data sets
• building a final list from smaller parts
• appending batches of records before processing

The most common and idiomatic approach is:

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

This appends all elements from v2 to the end of v1.

A key detail is that vectors may need to reallocate memory when they grow. If you know the final size in advance, calling reserve first can improve performance by reducing reallocations.

Think of a std::vector like a row of numbered boxes on a shelf.

• v1 is your first row of boxes.
• v2 is a second row of boxes.
• Concatenation means taking every box from v2 and placing copies of them at the end of v1.

If the shelf for v1 is too small, C++ may build a bigger shelf, move the old items over, and then add the new ones. That is why reserving enough space ahead of time can help.

Basic syntax

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

This means:

• start inserting at the end of v1
• take elements from v2.begin() up to v2.end()
• append them to v1

Example

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v1 = {1, 2, 3};
    std::vector<int> v2 = {4, 5, 6};

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

     ( n : v1) {
        std::cout << n << ;
    }
}

Consider this code:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> a = {10, 20};
    std::vector<int> b = {30, 40};

    a.insert(a.end(), b.begin(), b.end());

    for (int x : a) {
        std::cout << x << ' ';
    }
}

Step by step:

1. a starts as [10, 20]
2. b starts as [30, 40]
3. a.end() points to the position just after the last element of a
4. b.begin() points to 30
5. b.end() points just after 40

Concatenating vectors appears often in real C++ programs.

Common scenarios

• Merging search results: combine items returned from different queries
• Batch processing: append one batch of records to another before processing
• Game development: combine lists of visible objects, enemies, or events
• Parsing and tokenizing: merge token lists from multiple sources
• Data pipelines: collect values from several processing stages into one container
• Testing: combine expected values or test data sets

Example: collecting IDs from two services

std::vector<int> apiIds = {101, 102};
std::vector<int> cachedIds = {90, 95};

std::vector<int> allIds;
allIds.reserve(apiIds.size() + cachedIds.size());
allIds.insert(allIds.end(), cachedIds.begin(), cachedIds.end());
allIds.insert(allIds.end(), apiIds.begin(), apiIds.end());

This pattern is useful when building a final list from multiple sources.

In production code, developers usually choose the concatenation style based on ownership, performance, and readability.

Common patterns

Append into an existing vector

items.insert(items.end(), moreItems.begin(), moreItems.end());

Use this when items is the main collection being built.

Reserve before append

items.reserve(items.size() + moreItems.size());
items.insert(items.end(), moreItems.begin(), moreItems.end());

This is common in performance-sensitive code.

Build a new result vector

std::vector<int> combined;
combined.reserve(a.size() + b.size());
combined.insert(combined.end(), a.begin(), a.end());
combined.insert(combined.end(), b.begin(), b.end());

Use this when you want to keep inputs unchanged.

1. Expecting + to work

This does not work for std::vector in standard C++:

std::vector<int> a = {1, 2};
std::vector<int> b = {3, 4};

auto c = a + b; // Error

Fix

Use insert instead.

a.insert(a.end(), b.begin(), b.end());

2. Forgetting that insert modifies the target vector

std::vector<int> a = {1, 2};
std::vector<int> b = {3, 4};

a.insert(a.end(), b.begin(), b.end());

After this, a changes. If you need both originals unchanged, create a new vector first.

vs loop

Quick reference

Append one vector to another

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

Append with reserved capacity

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

Create a new concatenated vector

std::vector<int> result;
result.reserve(v1.size() + v2.size());
result.insert(result.end(), v1.begin(), v1.end());
result.insert(result.end(), v2.(), v());

How do you concatenate two std::vector objects in C++?

Use insert:

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

This appends all elements from v2 to v1.

Is there a + operator for std::vector in C++?

No. Standard C++ does not provide operator+ for std::vector.

What is the most efficient way to combine two vectors?

Usually, reserve enough space first and then use insert:

v1.reserve(v1.size() + v2.size());
v1.insert(v1.end(), v(), v());

• std::vector basics — helps you understand size, capacity, and element storage.
• push_back — useful for adding one element at a time.
• insert — the key function used to append a range of elements.
• reserve — improves performance by reducing reallocations.
• iterators — needed to understand begin() and end().
• move semantics — important when moving elements instead of copying them.
• range-based for loop — helpful for printing or processing concatenated vectors.
• copy vs move — explains performance and ownership trade-offs when combining containers.