C++ 如何使用存储在列表中的特定元素范围初始化向量？

我得到了一个

列表

和一个

向量

：

list<int> l;
for(int i=0; i<10; i++)
    l.push_back(i);

vector<int> v;

列表l；
对于（int i=0；i而言，最简单的解决方案是：

list<int> l;
for(int i=0; i<10; i++)
    l.push_back(i);

vector<int> v(l.begin(), l.begin()+5);

列表l；
对于（int i=0；i而言，最简单的解决方案是：

list<int> l;
for(int i=0; i<10; i++)
    l.push_back(i);

vector<int> v(l.begin(), l.begin()+5);

列表l；
对于（int i=0；i您无法避免循环，这正是列表的本质。对于数据的存储方式肯定没有保证，因此您不能使用memcpy之类的东西。如果您不想通过循环访问容器的元素，您不应该使用列表

正如其他答案所指出的，有许多紧凑的方法可以使用迭代器来实现这一点，但所有这些方法最终都会在列表中循环。
你无法避免循环，这是列表的本质。当然，无法保证数据是如何存储的，因此你不能使用memcpy之类的东西。如果你不想这样做的话o通过循环访问容器的元素，不应该使用列表

正如其他答案所指出的，有许多紧凑的方法可以使用迭代器来实现这一点，但它们最终都会在列表中循环。
您使用
std:：copy
和
std:：advance
（而不是
+
，用于非随机访问迭代器）：

#包括
#包括
#包括
#包括
int main（）{
std：：列表l；
对于（int i=0；i<10；i++）
l、 推回（i）；
std：：向量v；
v、 储备（5）；
std:：list:：iterator start=l.begin（），end=start；
标准：提前（结束，5）；
std:：copy（开始、结束、std:：back_inserter（v））；
std:：cout您使用
std:：copy
和
std:：advance
（而不是
+
，用于非随机访问迭代器）：

#包括
#包括
#包括
#包括
int main（）{
std：：列表l；
对于（int i=0；i<10；i++）
l、 推回（i）；
std：：向量v；
v、 储备（5）；
std:：list:：iterator start=l.begin（），end=start；
标准：提前（结束，5）；
std:：copy（开始、结束、std:：back_inserter（v））；
std：：cout这应该可以：

#include <list>
#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

struct convF
{
    convF( std::list<int>::const_iterator it_):it(it_){}

    int operator()()
    {
        return *it++;
    }

    std::list<int>::const_iterator it;
};

int main()
{
    std::list<int> l;
    std::vector<int> v;

    l.push_back(5);
    l.push_back(4);
    l.push_back(3);
    l.push_back(2);
    l.push_back(1);
    l.push_back(9);
    l.push_back(11);
    l.push_back(13);
    l.push_back(15);
    l.push_back(16);

    std::generate_n( std::back_inserter( v ), 5, convF(l.begin()) );

    std::copy( v.begin(), v.end(), std::ostream_iterator<int> (std::cout, " "));
    std::cout<<std::endl;
}

#包括
#包括
#包括
#包括
#包括
结构转换
{
convF（std：：list：：const_迭代器it_u）：it（it_u）{
int运算符（）（）
{
返回*it++；
}
std:：list:：const_迭代器it；
};
int main（）
{
std：：列表l；
std：：向量v；
l、 推回（5）；
l、 推回（4）；
l、 推回（3）；
l、 推回（2）；
l、 推回（1）；
l、 推回（9）；
l、 推回（11）；
l、 推回（13）；
l、 推回（15）；
l、 推回（16）；
std:：generate_n（std:：back_inserter（v），5，convF（l.begin（））；
std：：copy（v.begin（）、v.end（）、std：：ostream_迭代器（std：：cout，“”）；
std：：cout这应该可以：

#include <list>
#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

struct convF
{
    convF( std::list<int>::const_iterator it_):it(it_){}

    int operator()()
    {
        return *it++;
    }

    std::list<int>::const_iterator it;
};

int main()
{
    std::list<int> l;
    std::vector<int> v;

    l.push_back(5);
    l.push_back(4);
    l.push_back(3);
    l.push_back(2);
    l.push_back(1);
    l.push_back(9);
    l.push_back(11);
    l.push_back(13);
    l.push_back(15);
    l.push_back(16);

    std::generate_n( std::back_inserter( v ), 5, convF(l.begin()) );

    std::copy( v.begin(), v.end(), std::ostream_iterator<int> (std::cout, " "));
    std::cout<<std::endl;
}

#包括
#包括
#包括
#包括
#包括
结构转换
{
convF（std：：list：：const_迭代器it_u）：it（it_u）{
int运算符（）（）
{
返回*it++；
}
std:：list:：const_迭代器it；
};
int main（）
{
std：：列表l；
std：：向量v；
l、 推回（5）；
l、 推回（4）；
l、 推回（3）；
l、 推回（2）；
l、 推回（1）；
l、 推回（9）；
l、 推回（11）；
l、 推回（13）；
l、 推回（15）；
l、 推回（16）；
std:：generate_n（std:：back_inserter（v），5，convF（l.begin（））；
std：：copy（v.begin（）、v.end（）、std：：ostream_迭代器（std：：cout，“”）；
std：：coutNo，你不能对
list：：iterator
做算术运算。不，你不能对
list：：iterator
做算术运算。他在寻找一个循环的解决方案。问题不是这样说的。嗯，是的，基本上是这样。他甚至大声质疑
std：：copy
是否有帮助。
std：：copy
是一个好办法环绕循环的包装器。他正在寻找一个为他循环的解决方案。问题不是这样说的。嗯，是的，基本上是这样。他甚至大声怀疑
std:：copy
是否有帮助。
std:：copy
是环绕循环的包装器。@LightnessRacesinOrbit，呃，我的问题有什么问题吗？在C++11中有
std:：copy
（一旦你考虑升级你的编译器）@hmjd，对不起，我也没有使用
boost
。@jrok，是的，我正在考虑升级编译器，但是如何安装最新的g++？为什么不？我正在使用gcc 4.6.1，并且
copy\n
已经实现了。@LightnessRacesinOrbit，呃，我的问题有什么问题吗？在C++11中有
std:：copy\n
（一旦你考虑升级你的编译器）@hmjd，对不起，我也没有使用
boost
。@jrok，是的，我正在考虑升级编译器，但是如何？安装最新的g++？为什么不？我正在使用gcc 4.6.1，并且
copy\n
已经实现。使用
std:：copy
？请详细说明一下。你为什么要这样做而不是for循环？你基本上是在遍历你的collec重复两次，先在std:：advance中推进迭代器，然后在std:：copy中推进迭代器。5次也可以，但是当列表中有一千万个元素时，这将是一个真正的浪费时间。因此，从形式上来说，答案是正确的，但为什么要这样做呢？对于使用vector:：resize的循环，速度会更快。@mezhaka：确实，你不想这样做做吧。我确实说过它很慢，我之前的一次修改提到它会导致双重遍历。一个循环会更好；实际上你应该使用
vector:：reserve
。@naltmann:是的，没错。我本来不想被它困住，但我想我们也可以。@LightnessRacesinOrbit它是写给Alco的谢谢你的更正（保留）.使用
std:：copy
？请详细说明。为什么要这样做而不是for循环？基本上要遍历您的集合两次，先在std:：advance中推进迭代器，然后在std:：copy中推进迭代器。5次也可以，但当列表中有1000万个元素时，这将是真正的浪费时间。因此，正式地说，answer是正确的，但为什么要这样做呢？对于带有vector:：resize的循环，可以这样做