C++如何实现类的迭代器接口

iterator

const_iterator

*

->

++

==

!=

begin()

end()

MyVector

#include <cstddef>     // For std::ptrdiff_t
#include <iterator>    // For std::iterator_traits (及其相关概念)
#include <stdexcept>   // For std::out_of_range
#include <algorithm>   // 用于演示 std::sort, std::for_each

template <typename T>
class MyVector {
private:
    T* data;
    size_t current_size;
    size_t capacity;

    void reallocate(size_t new_capacity) {
        // 一个简单的重新分配逻辑，实际中可能更复杂，例如处理异常安全
        T* new_data = new T[new_capacity];
        for (size_t i = 0; i < current_size; ++i) {
            new_data[i] = data[i]; // 浅拷贝，实际应考虑深拷贝或移动语义
        }
        delete[] data;
        data = new_data;
        capacity = new_capacity;
    }

public:
    MyVector() : data(nullptr), current_size(0), capacity(0) {}
    MyVector(size_t initial_capacity) : current_size(0), capacity(initial_capacity) {
        data = new T[capacity];
    }
    ~MyVector() {
        delete[] data;
    }

    // 简化版push_back
    void push_back(const T& value) {
        if (current_size == capacity) {
            reallocate(capacity == 0 ? 1 : capacity * 2);
        }
        data[current_size++] = value;
    }

    T& operator[](size_t index) {
        if (index >= current_size) {
            throw std::out_of_range("Index out of bounds");
        }
        return data[index];
    }

    const T& operator[](size_t index) const {
        if (index >= current_size) {
            throw std::out_of_range("Index out of bounds");
        }
        return data[index];
    }

    size_t size() const { return current_size; }
    bool empty() const { return current_size == 0; }

    // --- 迭代器实现 ---
    class iterator {
    public:
        // 定义迭代器特性，这是与STL算法交互的关键
        using iterator_category = std::random_access_iterator_tag; // 随机访问迭代器
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;

    private:
        pointer ptr; // 迭代器内部通常只存储一个指向元素的指针

    public:
        // 构造函数
        iterator(pointer p = nullptr) : ptr(p) {}

        // 解引用操作符：访问当前元素
        reference operator*() const { return *ptr; }
        pointer operator->() const { return ptr; }

        // 前缀递增：++it
        iterator& operator++() {
            ++ptr;
            return *this;
        }

        // 后缀递增：it++
        iterator operator++(int) {
            iterator temp = *this; // 保存当前状态
            ++ptr;                 // 递增
            return temp;           // 返回递增前的状态
        }

        // 前缀递减：--it (双向迭代器需要)
        iterator& operator--() {
            --ptr;
            return *this;
        }

        // 后缀递减：it-- (双向迭代器需要)
        iterator operator--(int) {
            iterator temp = *this;
            --ptr;
            return temp;
        }

        // 随机访问操作符 (随机访问迭代器需要)
        iterator operator+(difference_type n) const { return iterator(ptr + n); }
        iterator operator-(difference_type n) const { return iterator(ptr - n); }
        difference_type operator-(const iterator& other) const { return ptr - other.ptr; }

        iterator& operator+=(difference_type n) { ptr += n; return *this; }
        iterator& operator-=(difference_type n) { ptr -= n; return *this; }

        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; }
    };

    // const_iterator 类似 iterator，但返回 const 引用，不允许修改元素
    class const_iterator {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = const T*;
        using reference = const T&;

    private:
        pointer ptr;

    public:
        const_iterator(pointer p = nullptr) : ptr(p) {}
        // 允许从非const迭代器隐式转换，这是为了让const MyVector::begin()返回const_iterator
        const_iterator(const iterator& other) : ptr(other.operator->()) {}

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

        const_iterator& operator++() { ++ptr; return *this; }
        const_iterator operator++(int) { const_iterator temp = *this; ++ptr; return temp; }
        const_iterator& operator--() { --ptr; return *this; }
        const_iterator operator--(int) { const_iterator temp = *this; --ptr; return temp; }

        const_iterator operator+(difference_type n) const { return const_iterator(ptr + n); }
        const_iterator operator-(difference_type n) const { return const_iterator(ptr - n); }
        difference_type operator-(const const_iterator& other) const { return ptr - other.ptr; }

        const_iterator& operator+=(difference_type n) { ptr += n; return *this; }
        const_iterator& operator-=(difference_type