C++ C++；复制一对向量<；int，int>；到向量<；int>；

我有一对向量，我需要把它们线性地复制到一个int向量。下面的代码运行良好，但我不确定C++中的结构填充问题是否安全。

std::vector < std::pair<int, int> > test_vector;
for (int i=0;i<5;i++) {
    test_vector.push_back(std::make_pair(i,i*5));
}
std::vector<int> int_vec(test_vector.size() * 2);
std::copy(reinterpret_cast<int*>(&(*test_vector.begin())),reinterpret_cast<int*>(&(*test_vector.end())),int_vec.begin());

std:：vectortest_vector；
对于（inti=0；iA
A
reinterpret\u cast
通常是个坏消息。你不觉得保留（reserve）更好吗在目标向量中输入足够的空间，然后对成对的源向量调用
std:：for each
，然后让函数/lambda将第一个和第二个都推回目标向量？
和lambda函数如何

std::vector<int> v;
std::transform(test_vector.begin(), test_vector.end(), std::back_inserter(v), 
               [&v](const std::pair<int, int> &p) 
               { v.push_back( p.first);
                 return p.second ;});

std:：vector v；
std:：transform（test_vector.begin（）、test_vector.end（）、std:：back_插入器（v），
[&v]（常数标准：：对和对）
{v.推回（p.第一）；
返回p.second；}）；

如果您不能使用C++11，并且可能“讨厌”使用循环进行线性复制

您可以像以下那样使用函子：

struct X{
    X(std::vector<int> &x) :v(x){}
    int operator () (const std::pair<int, int> &p)
    {
        v.push_back(p.first);
        return p.second;
    }
    std::vector<int> &v;
};

std::vector<int> v; //Final vector

std::transform(test_vector.begin(), 
               test_vector.end(), 
               std::back_inserter(v), 
               X(v));

std::vector<int> ::iterator it;

for(it=v.begin() ; it!=v.end() ;++it)
  std::cout<<*it<<" ";

struct X{
X（std:：vector&X）：v（X）{}
int运算符（）（const std:：pair&p）
{
v、 推回（第一页）；
返回p.second；
}
std：：vector&v；
};
std:：vector v；//最终向量
std:：transform（test_vector.begin（），
test_vector.end（），
标准：背面插入器（v），
X（v））；
std:：vector:：it迭代器；
for（it=v.begin（）；it！=v.end（）；+it）
std：：cout您关注结构填充问题是对的，但我认为您还没有真正面对代码正在生成的中心假设：

我可以将
std:：pair
视为两个整数的数组，其中
.first
是数组中的第一个元素，
.second
是第二个元素吗

从“正确性”的角度来看，我会说“否”。您已经确定了填充问题，但字段的顺序也有问题。确实无法保证
。first
的内存地址低于
。second

从一个“实用”的角度来看，我会很惊讶代码不起作用。[编辑：尼尔指出了一个具体的例子，其中有填充问题；所以我感到惊讶。除了“坏的形式”，我现在考虑代码在实践中被打破了。
对于解决方案，您可以使用
for_each
和一个自定义操作来推送对中的两个元素（未测试的代码）

struct操作{
动作（向量和目标）：t_3;（目标）{}
void运算符（）（常量对&p）常量
{t.push_back（p.first）；t.push_back（p.second）}
私人：
向量&t；
}
对于每个（test_vector.begin（）、test_vector.end（）、action（v））；
对于这个问题，您不需要任何幻想。一个简单的for循环就可以了，特别是当您不能使用C++11时

std::vector < std::pair<int, int> > test_vector;
std::vector<int> int_vec; int_vec.reserve(test_vector.size() * 2);
for (std::vector < std::pair<int, int> >::const_iterator it = test_vector.begin(), end_it = test_vector.end(); it != end_it; ++it)
{
    int_vec.push_back(it->first);
    int_vec.push_back(it->second);
}

std:：vectortest_vector；
std:：vector int_vec；int_vec.reserve（test_vector.size（）*2）；
对于（std:：vector：：常量迭代器it=test\u vector.begin（），end\u it=test\u vector.end（）；it！=end\u it；++it）
{
内部向量向后推（it->first）；
内部向量向后推（它->秒）；
}
这比编写循环更优雅？只是问问而已。我想从技术上讲，你可以从调用
std:：acculate
返回结果向量，算法名称在某种程度上是有意义的。当你考虑它时，它只有两行。实际上，如果我使用back\u inserter而不是在adv中分配它，它只有一行使用现有stl算法使用一行代码总是比编写容易出错的循环更优雅。特别是如果它是另一个例程的一部分。有趣。不幸的是，我对lambdas的了解非常有限。有没有一种方法可以在一次调用中不使用functor对象而将第一个和第二个元素都推回？我仍然使用C++03标准，但我可以使用Boost作为替代方法。我想不出一种方法可以在一次调用中不使用任何东西来做到这一点就像你已经拥有的一样。我想到函子是最安全/最可移植的方式。谢谢！不幸的是，还没有使用C++11（VS2008）但是我可以使用Booost .Calp用Boost来写一个.@ RWB，你可以编写一个函子类，而不是用在旧的C++中。当然，我当然可以写一个函子。但是只想知道是否有不同的方法，甚至是使用Booost。-9999999999999999，实际上这是可以的。如果我给了这个印象，就很抱歉。我的意思是说t。事实上，他编写的代码可以完成OP的尝试——这并不是一个好主意。除非不是因为填充问题。对。你有没有一个填充问题导致它失败的例子？int是32位，结构被填充到64位。循环很简单，使用其他任何东西都可能是一种过火的行为，但我很好奇它是否是pos可以使用stl算法。
std::vector < std::pair<int, int> > test_vector;
std::vector<int> int_vec; int_vec.reserve(test_vector.size() * 2);
for (std::vector < std::pair<int, int> >::const_iterator it = test_vector.begin(), end_it = test_vector.end(); it != end_it; ++it)
{
    int_vec.push_back(it->first);
    int_vec.push_back(it->second);
}