如何将std::向量转换为向量对std::向量使用STL算法？

Question

我有一个整数向量：

std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};

考虑到值。size（）将始终为偶数。

我只是想把相邻的元素转换成一对，像这样：

std::vector<std::pair<int,int>> values = { {1,2}, {3,4} , {5,6}, {7,8} ,{9,10} };

i、 两个相邻的元件连接成一对。

我可以使用什么STL算法轻松实现这一点？有没有可能通过一些标准算法来实现这一点？

当然，我可以很容易地编写一个旧的索引for循环来实现这一点。但我想知道，使用基于范围的for循环或任何其他STL算法（如std:：transform等）最简单的解决方案是什么样的。

Answer 1

我不知道有哪种标准算法可以直接满足您的需求（尽管我不太熟悉C 20及更高版本）。您总是可以编写一个循环，大多数循环都可以通过标准算法std:：for_each来表示。

由于您是成对累积元素，我想尝试一下std:：acculate

#include <vector>
#include <numeric>
#include <iostream>

struct pair_accumulator {
    std::vector<std::pair<int,int>> result;
    int temp = 0;
    bool set = false;
    pair_accumulator& operator+(int x){
        if (set) {
            result.push_back({temp,x});
            set = false;
        } else {
            temp = x;
            set = true;
        }
        return *this;
    }
};

int main() {
    std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};
    auto x = std::accumulate(values.begin(),values.end(),pair_accumulator{}).result;
    for (const auto& e : x) {
        std::cout << e.first << " " << e.second << "\n";
    }
}

诚然，这是否比编写普通循环更简单是值得怀疑的。

如果可能的话，我会尽量不变换向量。而不是访问结果[i]。首先您也可以使用值[i*2]和类似的值来表示第二个。如果这不可行，下一个选项是填充std:：vector

#include <vector>
#include <iostream>

struct view_as_pairs {
    std::vector<int>& values;

    struct proxy {
        std::vector<int>::iterator it;
        int& first() { return *it;}
        int& second() { return *(it +1); }
    };
    proxy operator[](size_t index){
        return proxy{values.begin() + index*2};
    }
    size_t size() { return values.size() / 2;}

};

int main() {
    std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};
    view_as_pairs v{values};
    for (size_t i=0; i < v.size(); ++i){
        std::cout << v[i].first() << " " << v[i].second() << "\n";
    }
}

TL；医生：考虑是否可以避免这种转变。如果无法避免，那么编写循环可能是最干净的。标准算法经常有用，但并不总是如此。

Answer 2

我不知道为什么在自己编写大约5行代码（加上样板文件）时需要标准算法：

template<class T>
std::vector<std::pair<T, T>> group_pairs(const std::vector<T>& values)
{
    assert(values.size() % 2 == 0);
    auto output = std::vector<std::pair<T, T>>();
    output.reserve(values.size()/2);
    for(size_t i = 0; i < values.size(); i+=2)
        output.emplace_back(values[i], values[i+1]);
    return output;
}

像这样称呼它：

std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};
auto result = group_pairs(values)

Answer 3

一旦我们有了C23的扩展名

#include <iostream>
#include <ranges>
#include <vector>

int main()
{
    std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};
    auto chunk_to_pair = [](auto chunk)
    {
        return std::pair(*chunk.begin(), *std::next(chunk.begin()));
    };
    for (auto [first, second] : values | std::ranges::views::chunk(2) | std::ranges::views::transform(chunk_to_pair))
    {
        std::cout << first << second << std::endl;
    }
}

或者，您可以通过ziping一对strided视图来实现类似的结果

#include <iostream>
#include <ranges>
#include <vector>

int main()
{
    std::vector<int> values = {1,2,3,4,5,6,7,8,9,10};
    auto odds = values | std::ranges::views::drop(0) | std::ranges::views::stride(2);
    auto evens = values | std::ranges::views::drop(1) | std::ranges::views::stride(2);
    for (auto [first, second] : std::ranges::views::zip(odds, evens))
    {
        std::cout << first << second << std::endl;
    }
}