如何在 C 中创建扁平化迭代器以简化嵌套容器上的迭代？

C 语言中的扁平化迭代器

传统的迭代器会遍历单个容器的元素，但有时我们会遇到嵌套容器，其中外部容器中的每个元素代表一个单独的容器。收藏。为了顺序遍历所有元素，我们需要一种机制来“展平”嵌套结构。

这就是展平迭代器发挥作用的地方。它们无缝地组合了多个级别的容器，将它们呈现为一个单一的有凝聚力的序列。人们可以使用标准的基于范围的循环来迭代展平的元素，就好像它们都包含在一个单一容器中一样。

实现

虽然没有内置实现主要的 C 库，可以制作一个示例实现：

#include <iterator>

template <typename OuterIterator>
class flattening_iterator {
public:
    using outer_iterator = OuterIterator;
    using inner_iterator = typename OuterIterator::value_type::iterator;

    using iterator_category = std::forward_iterator_tag;
    using value_type = typename inner_iterator::value_type;

    flattening_iterator() {}
    flattening_iterator(outer_iterator it) : outer_it_(it), outer_end_(it) {}
    flattening_iterator(outer_iterator it, outer_iterator end)
        : outer_it_(it), outer_end_(end) {
        if (outer_it_ == outer_end_) return;
        inner_it_ = outer_it_->begin();
        advance_past_empty_inner_containers();
    }

    reference operator*() const { return *inner_it_; }
    pointer operator->() const { return &*inner_it_; }

    flattening_iterator& operator++() {
        ++inner_it_;
        if (inner_it_ == outer_it_->end()) advance_past_empty_inner_containers();
        return *this;
    }

    flattening_iterator operator++(int) {
        flattening_iterator it(*this);
        ++*this;
        return it;
    }

    friend bool operator==(const flattening_iterator& a, const flattening_iterator& b) {
        if (a.outer_it_ != b.outer_it_) return false;
        if (a.outer_it_ != a.outer_end_ && b.outer_it_ != b.outer_end_ &&
            a.inner_it_ != b.inner_it_)
            return false;
        return true;
    }

    friend bool operator!=(const flattening_iterator& a, const flattening_iterator& b) {
        return !(a == b);
    }

private:
    void advance_past_empty_inner_containers() {
        while (outer_it_ != outer_end_ && inner_it_ == outer_it_->end()) {
            ++outer_it_;
            if (outer_it_ != outer_end_) inner_it_ = outer_it_->begin();
        }
    }

    outer_iterator outer_it_;
    outer_iterator outer_end_;
    inner_iterator inner_it_;
};

要使用这个扁平迭代器，我们可以利用 flatten 函数模板：

template <typename Iterator>
flattening_iterator<Iterator> flatten(Iterator it) {
    return flattening_iterator<Iterator>(it, it);
}

template <typename Iterator>
flattening_iterator<Iterator> flatten(Iterator first, Iterator last) {
    return flattening_iterator<Iterator>(first, last);
}

示例用法

考虑这个嵌套容器：

std::unordered_set<std::vector<int>> s;
s.insert(std::vector<int>());
s.insert({ 1, 2, 3, 4, 5 });
s.insert({ 6, 7, 8 });
s.insert({ 9, 10, 11, 12 });

通过利用展平迭代器，我们可以无缝迭代所有数字：

for (auto it(flatten(s.begin(), s.end())); it != s.end(); ++it) {
    std::cout << *it << endl;  // prints 1, 2, 3, ..., 12
}

结论

扁平化迭代器提供了一种高效且优雅的方法来以线性方式遍历嵌套容器。这种方法消除了对复杂嵌套循环或手动索引管理的需要。虽然不是标准库的一部分，但此实现可以轻松地合并到您的代码库中，以增强灵活性并提高可读性。

以上是如何在 C 中创建扁平化迭代器以简化嵌套容器上的迭代？的详细内容。更多信息请关注PHP中文网其他相关文章！