如何无需特化iterator_traits实现可组合反向迭代范围适配器？

先直接说核心问题：你的自定义reversed_iterator没有满足标准迭代器的关联类型要求，导致嵌套使用时std::iterator_traits无法正确推导reference等类型。下面给你两种可行的解决思路，覆盖C++11到新标准的场景：

方案1：给自定义迭代器补全标准关联类型（C++11兼容） #

你不需要给每个reversed_iterator特化iterator_traits，只需要在reversed_iterator结构体里显式定义所有标准要求的关联类型——标准库的iterator_traits会优先读取迭代器自身的这些类型定义，不用额外特化。

先看修改后的完整代码示例：

#include <iterator>

// 修正后的反向迭代器
template <typename Iter>
struct reversed_iterator {
    // 显式定义所有标准迭代器关联类型
    using iterator_type = Iter;
    using value_type = typename std::iterator_traits<Iter>::value_type;
    using reference = typename std::iterator_traits<Iter>::reference;
    using pointer = typename std::iterator_traits<Iter>::pointer;
    using difference_type = typename std::iterator_traits<Iter>::difference_type;
    using iterator_category = typename std::iterator_traits<Iter>::iterator_category;

    Iter it;
    reversed_iterator(Iter i) : it(i) {}
    
    // 补全必要的迭代器操作
    bool operator!=(const reversed_iterator& other) const { return it != other.it; }
    reversed_iterator& operator++() { --it; return *this; }
    reference operator*() const { return *it; } // 这里返回reference而非auto，确保类型匹配
    pointer operator->() const { return &(operator*()); }
};

// 修正后的反向范围适配器
template <typename Range>
struct reversed_range {
    Range& r;
    explicit reversed_range(Range& range) : r(range) {}

    // 区分非const和const版本的begin/end
    auto begin() { return reversed_iterator<decltype(r.end())>(r.end()); }
    auto end() { return reversed_iterator<decltype(r.begin())>(r.begin()); }

    auto begin() const { return reversed_iterator<decltype(r.cend())>(r.cend()); }
    auto end() const { return reversed_iterator<decltype(r.cbegin())>(r.cbegin()); }
};

// 辅助函数，简化调用
template <typename Range>
reversed_range<Range> reverse_range(Range& r) {
    return reversed_range<Range>(r);
}

template <typename Range>
reversed_range<const Range> reverse_range(const Range& r) {
    return reversed_range<const Range>(r);
}

现在嵌套使用就完全正常了：

int arr[] = {1,2,3,4};
// 反向迭代
for (auto x : reverse_range(arr)) {}
// 嵌套反向（等价于正向迭代）
for (auto x : reverse_range(reverse_range(arr))) {}

方案2：升级到C++20，直接用标准库的反向视图 #

如果你的项目可以升级到C++20，完全不用自己造轮子——标准库的std::views::reverse已经完美支持嵌套，并且天然符合所有范围迭代的标准要求：

#include <ranges>
#include <iostream>

int main() {
    int arr[] = {1,2,3,4};
    
    // 单次反向
    for (int x : arr | std::views::reverse) {
        std::cout << x << ' '; // 输出：4 3 2 1
    }
    std::cout << '\n';
    
    // 嵌套反向（回到正向）
    for (int x : arr | std::views::reverse | std::views::reverse) {
        std::cout << x << ' '; // 输出：1 2 3 4
    }
}

这是最省心的方案，标准库已经帮你处理了所有迭代器嵌套、const兼容、性能优化等细节。

为什么原来的嵌套会报错？ #

当你嵌套reverse_range(reverse_range(arr))时，外层的迭代器是reversed_iterator<reversed_iterator<int*>>。此时标准库会通过std::iterator_traits获取这个迭代器的reference类型，但你的原始reversed_iterator没有定义这些关联类型，导致iterator_traits无法推导，最终抛出“无reference类型”的错误。

而显式定义关联类型后，不管嵌套多少层，iterator_traits都能直接读取迭代器自身的类型定义，问题就解决了。

内容的提问来源于stack exchange，提问作者463035818_is_not_an_ai