C++迭代器适配器实战：STL算法与自定义数据结构桥接

1. 项目概述

在C++开发中，标准库算法（如sort、find、transform等）与容器解耦的关键在于迭代器的抽象。但实际项目中，我们常常遇到标准迭代器接口与业务数据结构不匹配的情况。这时候就需要通过适配器模式来桥接两者，让自定义数据结构也能无缝接入标准算法体系。

我曾在多个大型C++项目中处理过这类问题，比如需要将第三方库的专有数据结构适配到STL算法，或是为性能优化而设计的特殊迭代器。本文将分享几种经过实战检验的迭代器适配器实现方案，包含类型萃取、惰性求值等进阶技巧。

2. 核心需求解析

2.1 标准库算法的迭代器要求

STL算法对迭代器有明确的分类要求（输入/输出/前向/双向/随机访问）。以std::sort为例，它要求随机访问迭代器，必须实现以下操作：

cpp复制iter + n, iter - n, iter[n], --iter, iter1 - iter2

而自定义数据结构（如链表、树、图）的遍历器往往只满足更基础的迭代器类别。例如树的前序遍历器通常只符合前向迭代器要求。

2.2 典型适配场景

1. 跨库兼容：将第三方库的迭代器（如OpenCV的Mat迭代器）适配为STL迭代器
2. 视图转换：实现过滤视图（如只读偶数元素）、转换视图（如解引用指针集合）
3. 惰性计算：延迟执行昂贵操作直到真正解引用时
4. 线程安全：为多线程访问添加锁机制包装

3. 基础适配器实现

3.1 继承std::iterator的陷阱

传统教程常建议继承std::iterator（C++17已弃用），但更好的做法是直接定义以下类型别名：

cpp复制struct MyIterator {
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = ptrdiff_t;
    using pointer = T*;
    using reference = T&;
    // ... 操作符重载
};

3.2 输入迭代器适配示例

为传感器数据流实现适配器，将裸指针包装为符合STL要求的迭代器：

cpp复制template <typename T>
class SensorIterator {
    T* ptr;
public:
    using iterator_category = std::input_iterator_tag;
    // ... 其他类型定义
    
    reference operator*() const { 
        return *ptr; 
    }
    
    SensorIterator& operator++() {
        ptr = sensor_next_value(); // 调用硬件接口
        return *this;
    }
    
    friend bool operator==(const SensorIterator& a, const SensorIterator& b) {
        return a.ptr == b.ptr;
    }
    // ... 其他必要操作符
};

注意：输入迭代器不需要实现operator--，且允许单次遍历

4. 进阶适配模式

4.1 类型擦除适配器

当需要隐藏具体迭代器类型时（如实现运行时多态），可使用std::any+虚函数：

cpp复制class AnyIterator {
    struct Concept {
        virtual void increment() = 0;
        virtual any dereference() = 0;
        // ... 其他接口
    };
    
    template<typename Iter>
    struct Model : Concept {
        Iter iter;
        // ... 实现虚函数
    };
    
    std::shared_ptr<Concept> iter_;
public:
    // ... 转发接口到iter_
};

4.2 惰性求值适配器

实现只在解引用时执行计算的迭代器：

cpp复制template <typename Iter, typename Func>
class LazyTransformIterator {
    Iter base;
    Func f;
    mutable std::optional<decltype(f(*base))> cache;
public:
    auto operator*() const {
        if (!cache) cache = f(*base);
        return *cache;
    }
    
    LazyTransformIterator& operator++() {
        ++base;
        cache.reset();
        return *this;
    }
    // ... 其他接口
};

5. 性能优化技巧

5.1 内联关键操作

通过constexpr和inline确保适配器调用链能被编译器优化：

cpp复制template <typename T>
class CompactIterator {
    T* ptr;
public:
    constexpr reference operator*() const noexcept { 
        return *ptr; 
    }
    
    __attribute__((always_inline)) 
    CompactIterator& operator++() noexcept {
        ++ptr;
        return *this;
    }
};

5.2 避免虚函数开销

使用CRTP模式实现静态多态：

cpp复制template <typename Derived>
class IteratorAdapter {
    Derived& derived() { return static_cast<Derived&>(*this); }
    
    auto operator*() const { return derived().deref_impl(); }
    // ... 其他转发接口
};

class MyIter : public IteratorAdapter<MyIter> {
    friend class IteratorAdapter<MyIter>;
    int* ptr;
    int& deref_impl() const { return *ptr; }
};

6. 常见问题排查

6.1 迭代器类别不匹配

当算法拒绝编译时，检查static_assert：

cpp复制static_assert(std::is_same_v<
    typename std::iterator_traits<Iter>::iterator_category,
    std::random_access_iterator_tag>);

6.2 悬空引用问题

适配器持有引用时需特别小心生命周期：

cpp复制// 危险：临时对象生命周期问题
auto bad = std::find_if(
    LazyTransformIterator(begin, f),
    LazyTransformIterator(end, f),
    pred);

// 安全：延长原始数据生命周期
auto data = get_raw_data();
auto good = std::find_if(
    make_lazy_iter(begin(data), f),
    make_lazy_iter(end(data), f),
    pred);

7. 实战案例：数据库游标适配

将SQL查询结果适配为STL兼容迭代器：

cpp复制class DbResultIterator {
    using stmt_handle = std::shared_ptr<sqlite3_stmt>;
    stmt_handle stmt;
    bool is_end;
    
    void advance() {
        if (sqlite3_step(stmt.get()) != SQLITE_ROW) 
            is_end = true;
    }
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = DbRow;
    
    DbResultIterator(stmt_handle s, bool end = false) 
        : stmt(s), is_end(end) {}
        
    value_type operator*() const {
        return DbRow(stmt); 
    }
    
    DbResultIterator& operator++() {
        advance();
        return *this;
    }
    
    friend bool operator==(const DbResultIterator& a, const DbResultIterator& b) {
        return a.is_end == b.is_end;
    }
};

使用时只需：

cpp复制auto results = db.query("SELECT * FROM users");
std::vector<DbRow> rows(results.begin(), results.end());

8. 现代C++增强方案

8.1 C++20 ranges适配

利用views::transform等工具简化适配器实现：

cpp复制auto even_only = vec | std::views::filter([](int x) {
    return x % 2 == 0;
});

// 等效于手写适配器
std::sort(even_only.begin(), even_only.end());

8.2 概念约束

使用C++20概念明确接口要求：

cpp复制template <std::input_iterator Iter, typename Func>
class SafeTransformIterator {
    static_assert(std::is_invocable_v<Func, 
        typename std::iterator_traits<Iter>::reference>);
    // ... 实现
};

在实际工程中，我建议根据项目C++标准版本选择实现方案。对于C++17及以下环境，手写适配器仍是可靠选择；而在C++20项目中，优先考虑ranges和concepts能显著减少样板代码。