Concatenating two std::vectors

Efficiently Concatenating Two std::vectors in C++

Learn various methods to combine two std::vectors in C++, from simple loops to advanced algorithms, and understand their performance implications.

Concatenating std::vectors is a common operation in C++ programming, allowing you to combine elements from two separate dynamic arrays into one. While the concept is straightforward, C++ offers several approaches, each with its own advantages in terms of readability, performance, and resource usage. This article explores the most effective ways to achieve vector concatenation, guiding you through different scenarios and best practices.

Understanding the Basics of Vector Concatenation

At its core, concatenating two vectors means taking all elements from the first vector and appending all elements from the second vector to it, resulting in a new, larger vector. This operation typically involves resizing the target vector and then copying elements. The choice of method often depends on factors like the size of the vectors, whether you need a new vector or want to modify an existing one, and performance requirements.

flowchart TD
    A[Start with Vector A and Vector B]
    B{Choose Concatenation Method}
    B -- `insert()` --> C[Resize A, then insert B into A]
    B -- `std::copy()` --> D[Create new Vector C, copy A, then copy B]
    B -- Range-based constructor --> E[Create new Vector C from A, then append B]
    C --> F[Result: Modified Vector A]
    D --> G[Result: New Vector C]
    E --> G
    F & G --> H[End]

Flowchart illustrating different approaches to vector concatenation.

Method 1: Using std::vector::insert()

The std::vector::insert() method is a versatile way to add elements to a vector at a specified position. When concatenating, you can use it to insert all elements from the second vector at the end of the first vector. This method modifies the first vector in place. It's generally efficient for appending, as std::vector is optimized for insertions at the end.

#include <vector>
#include <iostream>

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

    // Insert elements of vec2 at the end of vec1
    vec1.insert(vec1.end(), vec2.begin(), vec2.end());

    for (int x : vec1) {
        std::cout << x << " ";
    }
    std::cout << std::endl; // Output: 1 2 3 4 5 6 

    return 0;
}

Concatenating vectors using std::vector::insert().

Method 2: Using std::copy() with a New Vector

If you need to create a new vector that contains the concatenated elements without modifying the original vectors, std::copy() is an excellent choice. This approach involves creating a new vector, resizing it to accommodate all elements, and then copying elements from both source vectors into it. This method is explicit and often preferred for clarity and immutability of source vectors.

#include <vector>
#include <algorithm> // For std::copy
#include <iostream>

int main() {
    std::vector<int> vec1 = {10, 20, 30};
    std::vector<int> vec2 = {40, 50, 60};

    // Create a new vector with enough space
    std::vector<int> vec_combined;
    vec_combined.reserve(vec1.size() + vec2.size());

    // Copy elements from vec1
    std::copy(vec1.begin(), vec1.end(), std::back_inserter(vec_combined));

    // Copy elements from vec2
    std::copy(vec2.begin(), vec2.end(), std::back_inserter(vec_combined));

    for (int x : vec_combined) {
        std::cout << x << " ";
    }
    std::cout << std::endl; // Output: 10 20 30 40 50 60 

    return 0;
}

Concatenating vectors into a new vector using std::copy() and std::back_inserter.

Method 3: Range-based Constructor and push_back() (or insert())

Another way to create a new concatenated vector is to initialize it with the first vector's elements using a range-based constructor, and then append the second vector's elements. This is often concise and readable.

#include <vector>
#include <iostream>

int main() {
    std::vector<double> vec1 = {1.1, 2.2};
    std::vector<double> vec2 = {3.3, 4.4, 5.5};

    // Initialize new_vec with elements from vec1
    std::vector<double> new_vec(vec1.begin(), vec1.end());

    // Append elements from vec2
    new_vec.insert(new_vec.end(), vec2.begin(), vec2.end());

    for (double d : new_vec) {
        std::cout << d << " ";
    }
    std::cout << std::endl; // Output: 1.1 2.2 3.3 4.4 5.5 

    return 0;
}

Concatenating vectors using a range-based constructor and insert().