c++ - 在多个 STL 对对象上创建迭代器

Question

我有一个具有以下签名的函数:

std::tuple<std::pair<float, float>, std::pair<float, float>> 
                                    computeBox(std::pair<float, float> p1,
                                               std::pair<float, float> p2,
                                               std::pair<float, float> p3,
                                               std::pair<float, float> p4);

现在我要做的是计算第 0 个和第 1 个索引的最小和最大元素。有一个 STL minmax_element 函数，它将一个范围作为输入。我的问题是如何从这些对对象的第 0 个和第一个索引创建一个范围？

Answer 1

My question is how can I create a range from the 0th and the 1st index from these pair objects?

为了好玩，这是我的第一次尝试:

#include <utility>
#include <algorithm>
#include <array>
#include <stdexcept>
#include <functional>

template<class A, class B>
struct pair_range;


template<class A> struct pair_range<A, A>
{
    using pair_type = std::pair<A, A>;

    struct iterator
    {
        iterator(pair_type const& p, std::size_t index)
        : data(std::addressof(p))
        , index(index)
        {}

        iterator()
        : data(nullptr)
        , index(0)
        {}

        static auto get0(pair_type const& p) -> const A& { return std::get<0>(p); }
        static auto get1(pair_type const& p) -> const A& { return std::get<1>(p); }
        static auto get2(pair_type const& p) -> const A& { throw std::invalid_argument("off end"); }
        static constexpr auto make_getters()
        {
            return std::array<A const& (*)(pair_type const&), 3>
            {
                get0, get1, get2
            };
        }

        A const& operator*() const {
            return make_getters()[index](*data);
        }

        iterator& operator++() {
            ++index;
            return *this;
        }

        bool operator==(iterator const& other) const {
            return data == other.data && index == other.index;
        }

        bool operator!=(iterator const& other) const {
            return not (*this == other);
        }

    private:
        pair_type const* data;
        std::size_t index;
    };

    pair_range(pair_type const& p)
    : begin_(p, 0)
    , end_(p, 2)
    {}

    auto begin() const { return begin_; }
    auto end() const { return end_; }

    iterator begin_, end_;
};

template<class A>
auto make_range(std::pair<A, A> const& pair)
{
    return pair_range<A const&, A const&>(std::make_pair(std::cref(std::get<0>(pair)),
                                                         std::cref(std::get<1>(pair))));
}
volatile int a, b;

int main()
{
    auto p = std::make_pair(1, 2);
    auto range = make_range(p);

    auto elems = std::minmax_element(range.begin(), range.end());
    a = *(elems.first);
    b = *(elems.second);
}