为不返回真实底层类型的迭代器实现operator->

你的核心问题是：迭代器对外要表现为pair<double&, double&>的迭代器，但内部用两个独立vector存储坐标，operator*()返回临时值无法取地址，不想每次堆分配。最优方案是用栈上的代理对象替代原生指针，利用C++迭代器operator->()的递归调用特性实现，完全避免堆内存操作。

实现思路 #

C++中，迭代器的operator->()不需要返回原生指针，只要返回一个对象，该对象的operator->()能最终访问到目标成员即可。我们可以定义一个轻量的代理结构体：

• 代理结构体持有x、y坐标的引用，模拟pair的first和second成员
• 代理的operator->()返回自身指针，让编译器递归调用以访问成员
• 迭代器的operator->()直接返回这个栈上的代理对象，无需堆分配

修正后的完整代码 #

struct PointArray {
    std::vector<double> m_x;
    std::vector<double> m_y;

    class iterator {
    public:
        // 修正迭代器关联类型：value_type用值类型，reference用引用类型
        using value_type = std::pair<double, double>;
        using reference = std::pair<double&, double&>;
        using pointer = pointer_proxy;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::random_access_iterator_tag;

        iterator() = default;
        iterator(std::vector<double>::iterator x_it, std::vector<double>::iterator y_it)
            : m_x_it(x_it), m_y_it(y_it) {}

        reference operator*() const { return {*m_x_it, *m_y_it}; }
        
        // 返回栈上的代理对象，无堆分配
        pointer operator->() const { return {*m_x_it, *m_y_it}; }

        iterator& operator++() { ++m_x_it; ++m_y_it; return *this; }
        iterator operator++(int) { auto copy = *this; ++(*this); return copy; }
        iterator& operator--() { --m_x_it; --m_y_it; return *this; }
        iterator operator--(int) { auto copy = *this; --(*this); return copy; }
        iterator& operator+=(difference_type n) { m_x_it += n; m_y_it += n; return *this; }
        iterator operator+(difference_type n) const { auto copy = *this; copy += n; return copy; }
        iterator& operator-=(difference_type n) { return (*this) += -n; }
        iterator operator-(difference_type n) const { auto copy = *this; copy -= n; return copy; }
        difference_type operator-(const iterator& other) const { return m_x_it - other.m_x_it; }
        reference operator[](difference_type n) const { return *(*this + n); }
        bool operator==(const iterator& other) const { return m_x_it == other.m_x_it; }
        bool operator!=(const iterator& other) const { return !(*this == other); }
        bool operator<(const iterator& other) const { return m_x_it < other.m_x_it; }
        bool operator<=(const iterator& other) const { return m_x_it <= other.m_x_it; }
        bool operator>(const iterator& other) const { return m_x_it > other.m_x_it; }
        bool operator>=(const iterator& other) const { return m_x_it >= other.m_x_it; }

    private:
        std::vector<double>::iterator m_x_it;
        std::vector<double>::iterator m_y_it;

        // 内部代理结构体，模拟pair的成员访问
        struct pointer_proxy {
            double& first;
            double& second;

            pointer_proxy(double& x, double& y) : first(x), second(y) {}

            // 关键：返回自身指针，让编译器递归解析成员访问
            pointer_proxy* operator->() const { return const_cast<pointer_proxy*>(this); }
        };
    };

    iterator begin() { return {m_x.begin(), m_y.begin()}; }
    iterator end() { return {m_x.end(), m_y.end()}; }

    // 补充const迭代器（可选）
    class const_iterator {
    public:
        using value_type = std::pair<double, double>;
        using reference = std::pair<const double&, const double&>;
        using pointer = const_pointer_proxy;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::random_access_iterator_tag;

        const_iterator() = default;
        const_iterator(std::vector<double>::const_iterator x_it, std::vector<double>::const_iterator y_it)
            : m_x_it(x_it), m_y_it(y_it) {}
        const_iterator(const iterator& other)
            : m_x_it(other.m_x_it), m_y_it(other.m_y_it) {}

        reference operator*() const { return {*m_x_it, *m_y_it}; }
        pointer operator->() const { return {*m_x_it, *m_y_it}; }

        // 其余运算符重载与iterator类似，略去...

    private:
        std::vector<double>::const_iterator m_x_it;
        std::vector<double>::const_iterator m_y_it;

        struct const_pointer_proxy {
            const double& first;
            const double& second;

            const_pointer_proxy(const double& x, const double& y) : first(x), second(y) {}
            const const_pointer_proxy* operator->() const { return this; }
        };
    };

    const_iterator begin() const { return {m_x.begin(), m_y.begin()}; }
    const_iterator end() const { return {m_x.end(), m_y.end()}; }
};

关键说明 #

1. 代理结构体的作用：pointer_proxy直接持有x、y的引用，完全在栈上创建，没有任何堆分配开销。
2. operator->()的递归解析：当你使用it->first时，编译器会先调用迭代器的operator->()得到pointer_proxy对象，然后调用pointer_proxy的operator->()得到自身指针，最后访问该指针的first成员，完美模拟原生pair的指针访问。
3. 关联类型修正：迭代器的value_type应该是元素的值类型（pair<double, double>）而非引用，这符合C++迭代器的标准约定。

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