c++中如何实现自定义容器的迭代器_c++迭代器模式代码实现【详解】-C++-PHP中文网

不能直接用 int* 当作自定义容器的迭代器，因为标准算法和范围 for 循环依赖迭代器的类型特征（如 iterator_category、value_type），裸指针不提供这些，会导致编译失败或行为不可控。

c++中如何实现自定义容器的迭代器_c++迭代器模式代码实现【详解】

为什么不能直接用 `int*` 当作自定义容器的迭代器

因为标准算法（如 std::sort、std::find）和范围 for 循环依赖迭代器的类型特征（如 iterator_category、value_type），裸指针不提供这些，会导致编译失败或行为不可控。比如 std::distance(it1, it2) 对裸指针虽能工作，但 std::advance 在输入迭代器场景下可能失效。

实操建议：

Web Accessibility (WCAG 2 AA))

将 WCAG 2 AA 无障碍标准应用于设计系统、UI 组件和网页——通过可运行的验证器进行对比度计算，采用设计 token 模式使颜色天生可访问，设定排版和焦点状态规则，并提供语义检查清单。适用于构建或审查 UI。

下载

必须在迭代器类中显式定义 typedef 或 using 别名： value_type、difference_type、pointer、reference、iterator_category
iterator_category 推荐从 std::random_access_iterator_tag（支持 +/-）、std::bidirectional_iterator_tag（仅支持 ++/--）中选，别硬写 std::input_iterator_tag 却实现随机访问操作
若容器底层是连续内存（如封装 std::vector），可直接用指针作为内部存储；否则需保存节点指针或索引

如何让 `begin()` / `end()` 返回正确的迭代器类型

关键不是返回什么，而是让编译器能推导出符合标准要求的类型——尤其要区分 const 和非 const 版本。常见错误是只实现一个 iterator 类型，导致 const Container& 调用 begin() 时返回可修改的迭代器，违反常量正确性。

实操建议：

为容器定义两个嵌套类型：iterator 和 const_iterator，二者通常复用同一模板类，仅通过模板参数控制解引用返回 T& 还是 const T&
begin() 和 end() 的 const 重载必须返回 const_iterator；非 const 版本返回 iterator
避免把 iterator 设为 const_iterator 的子类——C++ 标准不保证向下转换安全，且破坏了迭代器类型的正交性

operator++ 和 operator* 必须满足哪些语义约束

标准库算法依赖迭代器的“行为契约”。例如 operator++ 必须返回引用（前缀）或临时对象（后缀），operator* 必须返回可绑定到 T& 或 const T& 的结果，且不能有副作用。

实操建议：

前缀 ++it：返回 *this 的引用；后缀 it++：用临时对象保存旧值，再调用前缀，最后返回该临时对象
operator* 和 operator-> 应保持一致：若 *it 是 T&，则 it->member 等价于 (*it).member
禁止在 operator* 中做越界检查（性能敏感）；但可在调试版中用 assert 辅助定位问题

完整可编译的最小示例：基于数组的 `FixedArray` 迭代器

以下代码实现一个固定大小数组容器，含完整的 iterator / const_iterator，支持 ++、--、+、==、*，并能用于范围 for 和 std::sort：

#include <algorithm>
#include <cstddef><p>template <typename t std::size>t N>
class FixedArray {
T data[N];</typename></p>
<p>public:
using value_type = T;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using reference = T&;
using const_reference = const T&;
using pointer = T<em>;
using const_pointer = const T</em>;</p>
<pre class="brush:php;toolbar:false;">// 迭代器模板：IsConst 控制是否返回 const 引用
template <bool isconst>
class Iterator {
    static_assert(IsConst == true || IsConst == false, "");
    using element_type = std::conditional_t<isconst const t>;
    using pointer_type = std::conditional_t<isconst const t>;
    using reference_type = std::conditional_t<isconst const t>;

    pointer_type ptr_;

public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = pointer_type;
    using reference = reference_type;

    Iterator(pointer_type p) : ptr_(p) {}

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

    Iterator& operator++() { ++ptr_; return *this; }
    Iterator operator++(int) { Iterator tmp = *this; ++ptr_; return tmp; }
    Iterator& operator--() { --ptr_; return *this; }
    Iterator operator--(int) { Iterator tmp = *this; --ptr_; return tmp; }

    Iterator& operator+=(difference_type n) { ptr_ += n; return *this; }
    Iterator operator+(difference_type n) const { return Iterator(ptr_ + n); }
    friend Iterator operator+(difference_type n, const Iterator& it) { return it + n; }
    Iterator& operator-=(difference_type n) { ptr_ -= n; return *this; }
    Iterator operator-(difference_type n) const { return Iterator(ptr_ - n); }
    difference_type operator-(const Iterator& other) const { return ptr_ - other.ptr_; }

    reference operator[](difference_type n) const { return *(ptr_ + n); }

    bool operator==(const Iterator& other) const { return ptr_ == other.ptr_; }
    bool operator!=(const Iterator& other) const { return ptr_ != other.ptr_; }
    bool operator(const Iterator& other) const { return ptr_ > other.ptr_; }
    bool operator=(const Iterator& other) const { return ptr_ >= other.ptr_; }
};

using iterator = Iterator<false>;
using const_iterator = Iterator<true>;

iterator begin() { return iterator(data_); }
iterator end() { return iterator(data_ + N); }
const_iterator begin() const { return const_iterator(data_); }
const_iterator end() const { return const_iterator(data_ + N); }
const_iterator cbegin() const { return begin(); }
const_iterator cend() const { return end(); }</true></false></isconst></isconst></isconst></bool>

};

// 使用示例 int main() { FixedArray arr; arr.begin()[0] = 1; arr.begin()[1] = 2; arr.begin()[2] = 3;

std::sort(arr.begin(), arr.end()); // OK

for (int x : arr) {} // OK

const FixedArray<int> carr = arr;
for (int x : carr) {} // OK —— 调用 const_iterator</int>

}

注意：这个实现省略了 swap、assign 等接口，也未处理异常安全，但已覆盖所有迭代器协议核心要求。最容易被忽略的是 iterator_category 的正确继承关系和 const_iterator 与 iterator 的分离设计——一旦混用，std::find_if 等泛型算法会在 const 容器上静默编译失败。