C++ 将数据从浮点向量复制到浮点对向量

Question

我有一个目标标准向量：

 std::vector<std::pair<float,float> > allVertices;

为什么我要使用对，因为每 2 个浮点存在位置 pair(x,y)。现在，我有一个源 std:: 向量，它具有所有这些位置，但作为浮点数组（称为 m_vertices）。

我需要将所有数据从 m_vertices 复制到 allVertices 的末尾，并在复制过程中对数据进行转换。

std::transform 想到了Lambda，但我不知道如何从浮点向量复制到浮点对向量。

天真的：

    std::transform(m_vertices.begin(),m_vertices.end(),allVertices.end(),
                [](float x,float y)->std::pair<float,float>
            {
                return std::pair<float,float>(x * 100.0f,y * 100.0f)  ;
            }
            );

给我编译时错误：

错误 C2064：术语不计算为带 1 个参数的函数

还有一些更丑陋的东西。

顺便说一句，如果有人可以指出如何在 std::pair 结构中不需要的情况下转换数据对，那对我来说会更有帮助。

更新：

由于一些答案建议使用典型的迭代器，我想强调一下，我真的很想看看功能解决方案。如果可能的话。

Answer 1

这里的编译器信息很清楚：您的 lambda 必须采用 一个 输入参数，但您的 lambda 采用两个输入参数 x 和 y。您根本不能将std::transform 用于您的任务，因为std::transform 只接受单个值并转换它们，而不是值对。

以下是完成任务的三种可能方式：

简单的旧命令式编程

为什么不简单地使用这样的普通旧非功能方式：

for(auto it = m_vertices.begin(); it != m_vertices.end();++it){
    float x = *it;
    ++it;
    float y = *it;
    all_vertices.emplace_back(x*100f,y*100f);
}

确保m_vertices的大小是偶数；否则这段代码当然会崩溃。

Lamdas 和函数式编程很不错，但有时简单地以命令方式进行会更容易。

编写自己的对变换函数

您可以通过以下方式编写一个使用 lamdba 进行归约的函数：

template< class InputIt, class OutputIt, class BinaryReducerOp >
OutputIt transformPairs( InputIt first1, InputIt last1, OutputIt d_first,
                    BinaryReducerOp reducer_op );
    for(auto it = first1; it != last1;++it){
        auto& x = *it;
        ++it;
        if(it == last1) throw; // Input length not even!
        auto& y = *it;
        *d_first++ = reducer_op(x,y);
    }
}

现在您可以将此函数与您的 lambda 一起使用。即：

  transformPairs(m_vertices.begin(),m_vertices.end(),allVertices.end(),
                [](float x,float y)->std::pair<float,float>
            {
                return std::pair<float,float>(x * 100.0f,y * 100.0f)  ;
            }
            );

编写一对迭代器

正如 Steve Jessop 在他的评论中正确指出的那样，编写自己的对迭代器更加灵活，但也需要更多的工作。它可能看起来像这样（草图代码，这里没有编译器，可能包含小错误）：

template<typename It> struct PairIterator {
private:
    mutable It it; // mutable so we can move around in operator*
public:
    typedef decltype(it*) Element;

    PairIterator(const It& it) : it(it) {}

    bool operator!=(const PairIterator<It>& other) const { return other != it; }

    std::pair<Element, Element> operator*() const {
        const Element& e1 = it*;
        ++it;
        const Element& e2 = it*;
        --it;
        return std::make_pair(e1,e2);
    }

    PairIterator<It>& operator++(){
        ++it;
        ++it;
        return *this;
    } 
}

template<typename It>
make_pair_it(const It& it){ return PairIterator<It>(it); }

现在你可以像这样使用std::transform：

std::transform(make_pair_it(m_vertices.begin()),make_pair_it(m_vertices.end()),allVertices.end(),
                    [](std::pair<float,float> p)->std::pair<float,float>
                {
                    return std::pair<float,float>(p.first * 100.0f,p.second * 100.0f)  ;
                }
                );

Answer 2

对于您的问题，由于两个向量中的内存数组是相同的，您可以直接复制内存，这将是我认为最快的解决方案。

请注意，在将其应用于另一个案例之前，您必须确定自己在做什么，这很容易成为错误的根源。如果您尝试复制不同的类型（例如 double 到 float），它将不起作用。

allVertices.resize(m_vertices.size() / 2u);
std::copy_n(m_vertices.data(), m_vertices.size(), &(allVertices.front().first));

如果 m_vertices 大小不均匀，此代码也会中断。

然后您可以简单地使用一个范围广泛的基础 for 循环来应用您的处理

for (auto & pair: allVertices)
    treatment(pair);