Efficiently Concatenating `std::vector` in C++

Introduction

Concatenating two std::vector objects is a common task in C++ programming. Whether you’re dealing with simple data types or complex structures, understanding the most efficient way to combine vectors can significantly optimize your code’s performance. This tutorial explores different methods for concatenating vectors using standard library functions and modern C++ features.

Basic Concatenation

The simplest approach to concatenate two std::vector objects is by utilizing the insert method. This method appends all elements from one vector (src) to another (dest). Here’s how you can do it:

#include <vector>
#include <iostream>

int main() {
    std::vector<int> dest = {1, 2, 3, 4, 5};
    std::vector<int> src = {6, 7, 8, 9, 10};

    // Append elements from src to dest
    dest.insert(dest.end(), src.begin(), src.end());

    // Print concatenated vector
    for (int n : dest) {
        std::cout << n << " ";
    }
    return 0;
}

In this example, src is copied into dest. This method works well for simple data types but can become inefficient with complex structures due to the overhead of copying elements.

Moving Elements

Starting from C++11, you can take advantage of move semantics to transfer ownership of elements from one vector to another without unnecessary copies. This is particularly beneficial when dealing with non-trivially copyable objects or when src is no longer needed after concatenation.

Using std::move_iterator

The std::move_iterator wraps around an iterator, allowing you to move elements instead of copying them:

#include <vector>
#include <iostream>
#include <iterator>

int main() {
    std::vector<std::vector<int>> dest = {{1, 2, 3}, {4, 5}};
    std::vector<std::vector<int>> src = {{6, 7, 8}};

    // Move elements from src to dest
    dest.insert(dest.end(), std::make_move_iterator(src.begin()), std::make_move_iterator(src.end()));

    for (const auto& vec : dest) {
        for (int n : vec) {
            std::cout << n << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

After the move, src is left in a valid but unspecified state. This technique efficiently transfers elements without copying data.

Using std::copy and std::back_inserter

An alternative to insert for concatenating vectors involves using std::copy with std::back_inserter. This method is flexible, allowing you to append different types of containers or convert between types during the operation:

#include <vector>
#include <algorithm>
#include <iterator>

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

    // Append elements from src to dest using copy and back_inserter
    std::copy(src.begin(), src.end(), std::back_inserter(dest));

    for (int n : dest) {
        std::cout << n << " ";
    }
    return 0;
}

This approach is particularly useful when dealing with types that require conversion during concatenation.

Using std::move with std::back_inserter

For C++11 and later, you can use the std::move algorithm to move elements from one vector to another. This method leverages std::back_inserter for efficient appending:

#include <vector>
#include <algorithm>
#include <iterator>

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

    // Move elements from src to dest using move and back_inserter
    std::move(src.begin(), src.end(), std::back_inserter(dest));

    for (int n : dest) {
        std::cout << n << " ";
    }
    return 0;
}

This method is optimal when src can be left in an unspecified state post-move, as it avoids unnecessary data copying.

Conclusion

Concatenating vectors efficiently in C++ requires understanding the data being handled and choosing the appropriate method. Simple concatenation with insert works well for basic types but consider move semantics or algorithms like std::copy and std::move when working with complex structures or optimizing performance. By leveraging these techniques, you can write more efficient and maintainable C++ code.