Объединение двух std :: vectors

Если вас интересует строгая гарантия исключения 9X_stdvector (когда конструктор копирования может вызвать 9X_cpp исключение):

template
inline void append_copy(std::vector& v1, const std::vector& v2)
{
    const auto orig_v1_size = v1.size();
    v1.reserve(orig_v1_size + v2.size());
    try
    {
        v1.insert(v1.end(), v2.begin(), v2.end());
    }
    catch(...)
    {
        v1.erase(v1.begin() + orig_v1_size, v1.end());
        throw;
    }
}

Подобный append_move с сильной гарантией 9X_stl не может быть реализован в целом, если конструктор 9X_concat перемещения векторного элемента может бросать 9X_vector (что маловероятно, но все же).

Вам следует использовать vector::insert

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

9X_concat

Если ваша цель - просто перебрать диапазон 9X_concatenation значений только для чтения, альтернативой 9X_stl-containers является обернуть оба вектора вокруг прокси 9X_stdvector (O (1)) вместо их копирования (O (n)), чтобы 9X_concatenate они сразу же воспринимаются как единый, непрерывный.

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

VecProxy 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

Обратитесь 9X_vectors к https://stackoverflow.com/a/55838758/2379625 для получения дополнительных сведений, включая 9X_concatenate реализацию VecProxy, а также плюсы и минусы.

Добавьте это в свой заголовочный файл:

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

и 9X_concatenate используйте его так:

vector a = vector();
vector b = vector();

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

vector r = concat(a, b);

r будет содержать [1,2,62]

Используя C++20, вы можете избавиться от 9X_stdvector begin() и end() с диапазонами.

#include 

std::ranges::copy(vec2, std::back_inserter(vec1));

или если вы 9X_concatenate хотите переместить элементы:

std::ranges::move(vec2, std::back_inserter(vec1));

Вот решение общего назначения, использующее 9X_vectors семантику перемещения C++ 11:

template 
std::vector concat(const std::vector& lhs, const std::vector& rhs)
{
    if (lhs.empty()) return rhs;
    if (rhs.empty()) return lhs;
    std::vector result {};
    result.reserve(lhs.size() + rhs.size());
    result.insert(result.cend(), lhs.cbegin(), lhs.cend());
    result.insert(result.cend(), rhs.cbegin(), rhs.cend());
    return result;
}

template 
std::vector concat(std::vector&& lhs, const std::vector& rhs)
{
    lhs.insert(lhs.cend(), rhs.cbegin(), rhs.cend());
    return std::move(lhs);
}

template 
std::vector concat(const std::vector& lhs, std::vector&& rhs)
{
    rhs.insert(rhs.cbegin(), lhs.cbegin(), lhs.cend());
    return std::move(rhs);
}

template 
std::vector concat(std::vector&& lhs, std::vector&& rhs)
{
    if (lhs.empty()) return std::move(rhs);
    lhs.insert(lhs.cend(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
    return std::move(lhs);
}

Обратите внимание, чем 9X_vector это отличается от append от vector.

Вы можете подготовить свой собственный шаблон 9X_concatenate для оператора +:

template  
inline T operator+(const T & a, const T & b)
{
    T res = a;
    res.insert(res.end(), b.begin(), b.end());
    return res;
}

Следующее - просто используйте 9X_stdvector +:

vector a{1, 2, 3, 4};
vector b{5, 6, 7, 8};
for (auto x: a + b)
    cout << x << " ";
cout << endl;

Этот пример дает результат:

1 2 3 4 5 6 7 8

vector v1 = {1, 2, 3, 4, 5};
vector v2 = {11, 12, 13, 14, 15};
copy(v2.begin(), v2.end(), back_inserter(v1));
9X_vectors

Я реализовал эту функцию, которая объединяет 9X_vectors любое количество контейнеров, перемещаясь 9X_concatenation из rvalue-ссылок и копируя в противном случае

namespace internal {

// Implementation detail of Concatenate, appends to a pre-reserved vector, copying or moving if
// appropriate
template
void AppendNoReserve(Target* target, Head&& head, Tail&&... tail) {
    // Currently, require each homogenous inputs. If there is demand, we could probably implement a
    // version that outputs a vector whose value_type is the common_type of all the containers
    // passed to it, and call it ConvertingConcatenate.
    static_assert(
            std::is_same_v<
                    typename std::decay_t::value_type,
                    typename std::decay_t::value_type>,
            "Concatenate requires each container passed to it to have the same value_type");
    if constexpr (std::is_lvalue_reference_v) {
        std::copy(head.begin(), head.end(), std::back_inserter(*target));
    } else {
        std::move(head.begin(), head.end(), std::back_inserter(*target));
    }
    if constexpr (sizeof...(Tail) > 0) {
        AppendNoReserve(target, std::forward(tail)...);
    }
}

template
size_t TotalSize(const Head& head, const Tail&... tail) {
    if constexpr (sizeof...(Tail) > 0) {
        return head.size() + TotalSize(tail...);
    } else {
        return head.size();
    }
}

}  // namespace internal

/// Concatenate the provided containers into a single vector. Moves from rvalue references, copies
/// otherwise.
template
auto Concatenate(Head&& head, Tail&&... tail) {
    size_t totalSize = internal::TotalSize(head, tail...);
    std::vector::value_type> result;
    result.reserve(totalSize);
    internal::AppendNoReserve(&result, std::forward(head), std::forward(tail)...);
    return result;
}

Это решение может быть немного сложным, но 9X_vector boost-range может предложить и другие приятные вещи.

#include 
#include 
#include 

int main(int, char**) {
    std::vector a = { 1,2,3 };
    std::vector b = { 4,5,6 };
    boost::copy(b, std::back_inserter(a));
    for (auto& iter : a) {
        std::cout << iter << " ";
    }
    return EXIT_SUCCESS;
}

Часто 9X_stl-containers намерение состоит в том, чтобы объединить 9X_concatenation vector a и b, просто перебирая его, выполняя 9X_vector некоторую операцию. В этом случае есть нелепая 9X_concatenation простая функция join.

#include 
#include 
#include 
#include 

int main(int, char**) {
    std::vector a = { 1,2,3 };
    std::vector b = { 4,5,6 };
    std::vector c = { 7,8,9 };
    // Just creates an iterator
    for (auto& iter : boost::join(a, boost::join(b, c))) {
        std::cout << iter << " ";
    }
    std::cout << "\n";
    // Can also be used to create a copy
    std::vector d;
    boost::copy(boost::join(a, boost::join(b, c)), std::back_inserter(d));
    for (auto& iter : d) {
        std::cout << iter << " ";
    }
    return EXIT_SUCCESS;
}

Для больших векторов это 9X_vectors может быть преимуществом, поскольку отсутствует 9X_stdvector копирование. Его также можно использовать 9X_vector для простого копирования обобщений на более 9X_concatenation чем один контейнер.

По какой-то причине нет 9X_vector ничего похожего на boost::join(a,b,c), что могло бы быть разумным.

Для контейнеров, предлагающих push_back (строка, вектор, двухсторонняя 9X_stl-containers очередь, ...):

std::copy(std::begin(input), std::end(input), std::back_inserter(output))

и

для контейнеров, предлагающих 9X_concatenation insert (карты, наборы):

std::copy(std::begin(input), std::end(input), std::inserter(output, output.end()))