连接两个std::vector

我如何连接两个std::向量?

当前回答

vector1.insert( vector1.end(), vector2.begin(), vector2.end() );

2008-10-14 15:48:28

其他回答

我已经实现了这个函数，它连接任何数量的容器，从右值引用移动和复制

namespace internal {

// Implementation detail of Concatenate, appends to a pre-reserved vector, copying or moving if
// appropriate
template<typename Target, typename Head, typename... Tail>
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<Target>::value_type,
                    typename std::decay_t<Head>::value_type>,
            "Concatenate requires each container passed to it to have the same value_type");
    if constexpr (std::is_lvalue_reference_v<Head>) {
        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>(tail)...);
    }
}

template<typename Head, typename... Tail>
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<typename Head, typename... Tail>
auto Concatenate(Head&& head, Tail&&... tail) {
    size_t totalSize = internal::TotalSize(head, tail...);
    std::vector<typename std::decay_t<Head>::value_type> result;
    result.reserve(totalSize);
    internal::AppendNoReserve(&result, std::forward<Head>(head), std::forward<Tail>(tail)...);
    return result;
}

2019-07-11 21:10:12

如果您的目标只是为了只读目的而在值的范围内迭代，另一种替代方法是将两个向量围绕一个代理(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”实现以及优缺点。

2019-10-21 19:21:30

下面是一个使用c++ 11移动语义的通用解决方案:

template <typename T>
std::vector<T> concat(const std::vector<T>& lhs, const std::vector<T>& rhs)
{
    if (lhs.empty()) return rhs;
    if (rhs.empty()) return lhs;
    std::vector<T> 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 <typename T>
std::vector<T> concat(std::vector<T>&& lhs, const std::vector<T>& rhs)
{
    lhs.insert(lhs.cend(), rhs.cbegin(), rhs.cend());
    return std::move(lhs);
}

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

template <typename T>
std::vector<T> concat(std::vector<T>&& lhs, std::vector<T>&& 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);
}

注意这与附加到向量有何不同。

2018-03-08 13:48:05

在c++ 11中，我更喜欢将向量b附加到a:

std::move(b.begin(), b.end(), std::back_inserter(a));

当a和b不重叠时，b不会再被用到。

这是std::move from <algorithm>，而不是通常的std::move from <utility>。

2015-06-12 07:53:19

如果你正在寻找的是在创建后将一个向量附加到另一个向量的方法，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

2016-02-22 18:53:45

连接两个std::vector

推荐文章

最新文章

标签