<p>不能直接用 int* 当作自定义容器的迭代器，因为标准算法和范围 for 循环依赖迭代器的类型特征（如 iterator_category、value_type），裸指针不提供这些，会导致编译失败或行为不可控。</p>
为什么不能直接用 int* 当作自定义容器的迭代器
因为标准算法（如 std::sort、std::find）和范围 for 循环依赖迭代器的类型特征（如 iterator_category、value_type），裸指针不提供这些，会导致编译失败或行为不可控。比如 std::distance(it1, it2) 对裸指针虽能工作，但 std::advance 在输入迭代器场景下可能失效。
实操建议：
立即学习“C++免费学习笔记（深入）”；
- 必须在迭代器类中显式定义
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() 时返回可修改的迭代器，违反常量正确性。
实操建议：
立即学习“C++免费学习笔记（深入）”；
- 为容器定义两个嵌套类型：
iterator和const_iterator，二者通常复用同一模板类，仅通过模板参数控制解引用返回T&还是const T& -
begin()和end()的const重载必须返回const_iterator；非const版本返回iterator - 避免把
iterator设为const_iterator的子类——C++ 标准不保证向下转换安全，且破坏了迭代器类型的正交性
operator++ 和 operator* 必须满足哪些语义约束
标准库算法依赖迭代器的“行为契约”。例如 operator++ 必须返回引用（前缀）或临时对象（后缀），operator* 必须返回可绑定到 T& 或 const T& 的结果，且不能有副作用。
实操建议：
立即学习“C++免费学习笔记（深入）”；
- 前缀
++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<em>t N>
class FixedArray {
T data</em>[N];</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, T>;
using pointer_type = std::conditional_t<IsConst, const T*, T*>;
using reference_type = std::conditional_t<IsConst, const T&, 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_; }
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(); }};
// 使用示例 int main() { FixedArray<int, 3> 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, 3> carr = arr;
for (int x : carr) {} // OK —— 调用 const_iterator}
注意：这个实现省略了 swap、assign 等接口，也未处理异常安全，但已覆盖所有迭代器协议核心要求。最容易被忽略的是 iterator_category 的正确继承关系和 const_iterator 与 iterator 的分离设计——一旦混用，std::find_if 等泛型算法会在 const 容器上静默编译失败。
