c++ 如何在结构向量的一个字段上创建迭代器

Question

我有一个所有原始类型的结构，如下所示：

struct record {
    int field1;
    double field2;
}

我有这个结构的实例向量，如下所示：

vector<record> records;

是否有可能/创建将迭代 field1 的 vector<int>::iterator 的最佳方法是什么？ 如果我使用数组record records[n] 会怎样？我需要看起来像 vector<int>::iterator 的东西。

编辑：我需要vector<int>::iterator。

Answer 1

制作迭代器适配器

首先，最简单的解决方案是遍历容器并从迭代器中访问字段。

for (auto&& r : records) {
    int value = r.field1;
    /* do something with 'value' */
}

无论如何，如果您真的想要一个在取消引用时返回 field1 的迭代器，您可以轻松实现一个从容器自己的迭代器派生的迭代器适配器。

struct my_it : public std::vector<record>::iterator {
    using std::vector<record>::iterator::iterator;
    int operator*() { return std::vector<record>::iterator::operator*().field1; }
};

并像这样使用它：

for (my_it it = std::begin(records); it != std::end(records); ++it) {
    int value = *it; // Dereferencing now returns 'field1'.
}

是 XY 问题吗？

正如Ben Voigt 的回答中所解释的那样，除了存储在连续数组中的int 元素之外，没有办法创建一个std::vector<int>::iterator 来迭代其他东西。

如果您需要一个接受输入迭代器的函数，则将其设为 模板函数。这样，它将与 any 容器类型的迭代器一起使用。这就是标准库中所有算法的实现方式。

template <typename InputIt>
void func(InputIt first, InputIt last) {
    for (; first != last; ++first) {
        value = *it; // Dereferences input iterator of any type.
    }
}

迭代器应该通过它们的操作（即读取、递增、递减、随机访问）进行接口，而不是它们的显式类型。迭代器按其支持的操作数分类。

例如，如果您需要遍历一个范围并一次读取所有值，那么您希望 输入迭代器 作为参数。迭代器本身的类型应该是无关紧要的。

See this for more info about iterator categories

Answer 2

你运气不好。

vector<int>::iterator 不是多态的¹。没有地方可以进入并更改指针步长。 vector<int>::iterator 仅迭代一系列连续 int 对象，而您的int 对象不会连续存储。

这就是为什么所有 C++ 标准算法都被模板化以接受任何类型的迭代器。如果你让你的函数成为接受任意迭代器类型的模板，你可以使用像 Snps 写的那样的迭代器适配器。

---

¹多态性慢相对于指针算术，如果std::vector没有与普通数组类似的性能，没有人会使用它

Answer 3

您可以在原始 vector 上使用 lambda。

例如：

for_each(records.begin(), records.end(), [](record& foo){/*operate on foo.field1 here*/});

请注意，绝大多数其他算法也接受 lambda，因此您只需使用 lambda 迭代原始 vector 即可访问 field1。

我在这里冒昧，但您正在寻找的行为似乎与 map 的行为非常相似，所以您可能想看看。

我想你喜欢 Boost 和 evil，你也可以用这个来拼凑一些东西：http://www.boost.org/doc/libs/1_57_0/libs/range/doc/html/range/reference/adaptors/reference/strided.html

Answer 4

看来你要的是这样的东西

for(std::vector<record>::iterator i=records.begin(), end=records.end(); i!=end; ++i)
{
    std::cout << i->field1 << std::endl;
}

或者在 C++11 中

for(auto i=records.begin(), end=records.end(); i!=end; ++i)
{
    std::cout << i->field1 << std::endl;
}

Answer 5

如果你真的想要一个成员迭代器，你可以这样做：

template <class M>
struct member_traits;

template <class T, class C>
struct member_traits<T C::*>
{
    using class_type = C;
    using return_type = T;
};

template <class Iterator, class C, class M>
struct member_iterator : Iterator
{
public:
    using Iterator::Iterator;

    template <class I, class Member>
    member_iterator(I&& begin, Member&& member)
        : std::vector<C>::iterator(std::forward<I>(begin))
        , member(std::forward<Member>(member))
    {
        static_assert(std::is_member_pointer<Member>::value,
                      "Member must be dereferenceable");
    }

    typename member_traits<M>::return_type& operator*()
    {
        return (*static_cast<Iterator&>(*this)).*member;
    }
private:
    M member;
};

template <class Member, class Iterator>
auto make_member_iterator(Member&& member, Iterator&& it)
    -> member_iterator<std::decay_t<Iterator>, typename member_traits<Member>::class_type, std::decay_t<Member>>
{
    return {std::forward<Iterator>(it), std::forward<Member>(member)};
}

struct Record
{
    int field1;
    double field2;
};

int main()
{
    std::vector<Record> v { {1, 1.0}, {2, 2.0}, {3, 3.0} };

    for (auto it = make_member_iterator(&Record::field1, v.begin()); it != v.end(); ++it)
    {
        std::cout << *it << " ";
    }
}

Demo