C++ 用另一个向量扩展一个向量

Posted 2023-02-24

【中文标题】C++ 用另一个向量扩展一个向量

【英文标题】：C++ extend a vector with another vector

【发布时间】：2010-09-23 17:28:31

【问题描述】：

我是 C++ 领域的 C/Python 程序员，第一次使用 STL。

在 Python 中，用另一个列表扩展一个列表使用 .extend 方法：

>>> v = [1, 2, 3]
>>> v_prime = [4, 5, 6]
>>> v.extend(v_prime)
>>> print(v)
[1, 2, 3, 4, 5, 6]

我目前使用这种算法方法来扩展 C++ 中的向量：

v.resize(v.size() + v_prime.size());
copy(v_prime.begin(), v_prime.end(), v.rbegin());

这是扩展向量的规范方法，还是我缺少一种更简单的方法？

【问题讨论】：

Concatenating two std::vectors的可能重复

【参考方案1】：

来自here

// reserve() is optional - just to improve performance
v.reserve(v.size() + distance(v_prime.begin(),v_prime.end()));
v.insert(v.end(),v_prime.begin(),v_prime.end());

【讨论】：

我不认为 vector::insert 专门用于随机访问输入迭代器，所以如果性能很重要，请先使用 reserve()。

VC++ 9.0 和 GCC 4.3.2 都在内部确定迭代器类别，因此您无需预留。

我知道这已经 8 岁了，但是你有什么理由使用distance() 而不是简单的v_prime.size()？

@Holt 他可能正在考虑更一般的情况，您希望将向量扩展某些元素范围。例如，如果您不想使用 v_prime 中的所有元素，则可以使用此代码并替换迭代器。

【参考方案2】：

copy(v_prime.begin(), v_prime.end(), back_inserter(v));

【讨论】：

我觉得空间还是要reserve()-d来提高性能

+1，因为提问者要求“最简单”，而不是“最快”，所以没有必要保留空间（虽然值得一提）。

我认为 dmitry 解决方案既简单又快捷。为这个人点赞 :)

这个答案应该被劝阻。请参阅 Effective STL，第 5 项：太多 STL 程序员过度使用 copy，因此我刚才给出的建议值得重复：几乎所有使用 copy 的使用插入迭代器指定目标范围的用法都应替换为对范围成员的调用功能。

@Chris，从而破坏了 STL 的架构。

【参考方案3】：

我需要 C++14 中 extend 函数的两种不同变体，其中一个支持要附加的向量的每个元素的移动语义。

vec 是你的v，ext 是你的v_prime。

/**
 * Extend a vector with elements, without destroying source one.
 */
template<typename T>
void vector_extend(std::vector<T> &vec, const std::vector<T> &ext) 
    vec.reserve(vec.size() + ext.size());
    vec.insert(std::end(vec), std::begin(ext), std::end(ext));


/**
 * Extend a vector with elements with move semantics.
 */
template<typename T>
void vector_extend(std::vector<T> &vec, std::vector<T> &&ext) 
    if (vec.empty()) 
        vec = std::move(ext);
    
    else 
        vec.reserve(vec.size() + ext.size());
        std::move(std::begin(ext), std::end(ext), std::back_inserter(vec));
        ext.clear();
    

【参考方案4】：

有多种方法可以实现您的目标。

std::vector::insert

可以通过在指定位置的元素之前插入新元素来扩展向量，通过插入的元素数量有效地增加容器大小。您可以遵循以下方法之一。第二个版本使用 C++11，它可以被认为是一个更通用的答案，因为 b 也可以是一个数组。

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

有时在使用中最好在使用 std::vector::insert 之前使用保留函数。 std::vector::reserve 函数将容器的容量增加到大于或等于 new_cap 的值。如果 new_cap 大于当前容量（），则分配新存储，否则该方法不执行任何操作。

a.reserve(a.size() + distance(b.begin(), b.end()));

保留功能不是必需的，但可能是可取的。如果您重复插入一个您知道最终大小并且该大小很大的向量，那么最好使用保留。否则，最好让 STL 根据需要增长您的向量。

std::copy

std::copy 是您可以考虑实现目标的第二个选项。该函数将范围（first，last）中的元素复制到从 result 开始的范围中。

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

但是使用 std::copy 比使用 std::vector::insert() 慢，因为 std::copy() 不能预先预留足够的空间（它无法访问vector 本身，仅适用于具有的迭代器），而作为成员函数的 std::vector::insert() 可以。由于 std::copy 确实比使用 std::vector::insert 慢。大多数人在不知道这种情况的情况下过度使用 std::copy。

boost::push_back

您可以考虑的第三个选项是使用 boost 的 push_back 函数。

boost::push_back(a, b);

【参考方案5】：

使用std::vector::insert;

A.reserve(A.size() + B.size());
A.insert(A.end(), B.begin(), B.end());

reserve() 是可选的，但使用它有助于提高性能。

---

方便的代码生成器可以节省宝贵的时间：

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.98.0/css/materialize.min.css"><script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.98.0/js/materialize.min.js"></script><script src="https://cdn.jsdelivr.net/clipboard.js/1.6.0/clipboard.min.js"></script><script>function generateCode()codeTemplate="0.reserve(0.size() + 1.size()); \n0.insert(0.end(), 1.begin(), 1.end());",first=document.getElementById("1").value,second=document.getElementById("2").value,""==first&&(first="A"),""==second&&(second="B"),document.getElementById("c").innerhtml=String.format(codeTemplate,first,second)String.format||(String.format=function(a)var b=Array.prototype.slice.call(arguments,1);return a.replace(/(\d+)/g,function(a,c)return"undefined"!=typeof b[c]?b[c]:a));</script><div class="A" style="margin:3% 10% 1% 10%;"><label for="1">First vector name:</label><input id="1"/><br/><label for="1">Second vector name:</label><input id="2"/><div class="D"><a class="waves-effect waves-light btn red col" onclick="generateCode();" style="margin:0 0 4% 0;">Generate Code</a></div><textarea id="c" onclick="this.select()" style="border:none;height:auto;overflow: hidden;font-family:Consolas,Monaco;">A.reserve(A.size() + B.size());
A.insert(A.end(), B.begin(), B.end());</textarea></div>

【讨论】：

这是 11 年后投票最多的答案 ***.com/a/313444/931303 的副本。考虑删除它。

本来打算投反对票的，但我喜欢代码生成器，所以 +1 来表示原创性。

【参考方案6】：

仅使用以下语法：

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

除非您知道自己在做什么，否则不应使用 Reserve\Resize。

保留可能会导致大量开销，因为它不一定会分配大小的指数增长，因此每个保留都可能导致 O(n) 时间。

如果只完成一次，这可能不会非常昂贵，并且在这种情况下实际上可能会证明更多的时间\内存效率。另一方面，如果您继续使用相对较小的数组以这种方式扩展数组，这将证明非常效率低下。以下示例显示了一个简单的误用，导致时间增加 x10,000 ?

示例：

#include <vector>
#include <iostream>
#include <chrono>

int main() 
    std::vector<int> a, b(50);
    auto t1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 5e4; i++) 
        a.reserve(a.size() + b.size());      // line in question.
        a.insert(a.end(), b.begin(), b.end());
    
    auto t2 = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>( t2 - t1 ).count();

    std::cout << 1.0 * duration / 1e9;
    return 0;


//run              time        complexity      speed up
//with reserve     114.558 s   O(N)            x1
//without reserve    0.012 s   O(N^2)          x10000 (~O(N/50))

在 gcc 17、intel i5 上使用 -O3 编译。

【讨论】：

这个答案可以更好地解释正在发生的事情。如果不手动保留空间，即让向量管理其空间，则内存分配的摊销成本为 O(1)。这是通过以指数方式分配内存来实现的。在此示例中，使用手动保留，内存分配的大小是线性的（每次分配中多了 50 个元素），导致内存分配的成本为 O(n)。当然，O(1) 比 O(n) 快。