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

Question

我有一个目标标准 vector :

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

为什么我要使用对，因为每 2 个 float 都存在位置对(x，y)。现在，我有一个源 std:: vector ，它具有所有这些位置，但作为 float 组(称为 m_vertices)。

我需要将所有数据从 m_vertices 复制到 allVertices 的末尾，并在复制期间执行数据转换。

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

天真:

    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)  ;
            }
            );

给我编译时错误:

error C2064: term does not evaluate to a function taking 1 arguments

还有一些更丑陋的东西。

顺便说一句，如果有人能指出如何在不需要 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)  ;
                }
                );