C++迭代器中operator->运算符的用法疑问及示例解答

核心逻辑 #

迭代器的operator->是为了模拟指针的行为，让你能用it->member的语法访问迭代器指向元素的成员，哪怕迭代器本身是封装的类（无公共成员）。它的本质是返回一个指向目标元素的指针（或可链式调用operator->的代理对象），编译器会自动完成后续的成员访问。

标准库迭代器示例 #

以std::vector的随机访问迭代器为例：

#include <vector>
#include <iostream>

struct Person {
    std::string name;
    int age;
};

int main() {
    std::vector<Person> people = {{"Alice", 25}, {"Bob", 30}};
    
    auto it = people.begin();
    // 使用operator->直接访问元素成员
    std::cout << "Name: " << it->name << ", Age: " << it->age << "\n";
    
    // 等价于解引用后访问成员，两种写法效果一致
    std::cout << "Name: " << (*it).name << ", Age: " << (*it).age << "\n";
    
    ++it;
    std::cout << "Name: " << it->name << ", Age: " << it->age << "\n";
}

运行输出：

Name: Alice, Age: 25
Name: Alice, Age: 25
Name: Bob, Age: 30

底层实现原理（自定义迭代器示例） #

标准库迭代器的operator->本质是返回指向容器元素的指针。我们可以手动实现一个简单的随机访问迭代器，直观理解其工作方式：

#include <iostream>
#include <string>

template <typename T>
class MyVector {
private:
    T* data;
    size_t size_;
public:
    MyVector(T* arr, size_t size) : size_(size) {
        data = new T[size];
        for (size_t i = 0; i < size; ++i) {
            data[i] = arr[i];
        }
    }
    
    ~MyVector() { delete[] data; }
    
    // 自定义随机访问迭代器
    class Iterator {
    private:
        T* ptr; // 指向容器中的实际元素
    public:
        explicit Iterator(T* p) : ptr(p) {}
        
        // 重载operator->，返回指向元素的指针
        T* operator->() const {
            return ptr;
        }
        
        // 重载operator*，返回元素引用
        T& operator*() const {
            return *ptr;
        }
        
        Iterator& operator++() {
            ++ptr;
            return *this;
        }
        
        bool operator==(const Iterator& other) const {
            return ptr == other.ptr;
        }
        
        bool operator!=(const Iterator& other) const {
            return !(*this == other);
        }
    };
    
    Iterator begin() { return Iterator(data); }
    Iterator end() { return Iterator(data + size_); }
};

struct Person {
    std::string name;
    int age;
};

int main() {
    Person people_arr[] = {{"Alice", 25}, {"Bob", 30}};
    MyVector<Person> vec(people_arr, 2);
    
    auto it = vec.begin();
    std::cout << "Name: " << it->name << ", Age: " << it->age << "\n";
    
    ++it;
    std::cout << "Name: " << it->name << ", Age: " << it->age << "\n";
}

在这个自定义迭代器中，operator->直接返回指向容器元素的指针ptr。当你写it->name时，编译器会展开为(it.operator->())->name，也就是ptr->name，和直接用指针访问成员的逻辑完全一致。

特殊情况：代理迭代器 #

少数场景下，迭代器的operator->会返回一个代理对象而非原始指针，这个代理对象也重载了operator->。编译器会自动递归调用operator->，直到拿到真正的指针再访问成员。不过这种情况在随机访问迭代器中并不常见，更多出现在智能指针或某些特殊迭代器中。

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