Question

我是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());

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

Answer 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());

Answer 2

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

Answer 3

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

<强>的std ::矢量::插入

可以通过在元素之前在指定位置插入新元素来扩展向量，从而有效地增加容器大小所插入的元素数量。您可以按照以下方法之一进行操作。第二个版本使用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大于当前capacity（），则分配新存储，否则该方法不执行任何操作。

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

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

<强>的std ::复制

std :: copy是您可以考虑实现目标的第二个选项。此函数将范围（第一个，最后一个）中的元素复制到从结果开始的范围内。

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

然而，使用std :: copy比使用std :: vector :: insert（）要慢，因为std :: copy（）之前无法保留足够的空间（它无法访问向量本身，只有一个迭代器有），而std :: vector :: insert（），是一个成员函数，可以。由于std :: copy确实比使用std :: vector :: insert慢。大多数人，在不知道这种情况的情况下过度使用std :: copy。

<强>升压::的push_back

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

boost::push_back(a, b);

Answer 4

我需要在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();
    }
}

Answer 5

使用std::vector::insert;

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

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

Convienent代码生成器可节省宝贵的秒数：

<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()); \n{0}.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());&#13;&#10;A.insert(A.end(), B.begin(), B.end());</textarea></div>

Answer 6

仅使用以下语法：

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

除非您知道自己在做什么，否则不要使用

保留\调整大小。

预留空间可能会导致大量的开销，因为它不一定会分配大小的指数增长，因此每个预留空间都可能导致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编译。

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

6 个答案: