如何正确包装非连续内存的STL容器迭代器？以std::deque为例

核心问题 #

你实现的FooQueue自定义容器，试图用裸指针封装迭代器来避免暴露std::deque::iterator，但这种方式存在两个致命问题：

• 解引用std::deque::end()属于未定义行为，因为它不指向任何有效元素；
• std::deque的内存是非连续的，裸指针自增无法正确遍历容器（下一个元素可能在完全不同的内存块），你的迭代器遍历逻辑本身就是错误的。

正确实现方式 #

不要用裸指针实现迭代器，而是让自定义迭代器内部包装std::deque<Foo>::iterator。这种方式既不会暴露内部的deque迭代器给外部，又能完全复用deque迭代器的合法行为，同时保证遍历的正确性。

修改后的代码示例 #

struct Foo;
using FooId = int; // 假设FooId为int类型，可根据实际场景调整

// 自定义容器
class FooQueue{
public:
  FooId PushFront(Foo& foo);
  FooId PushBack(Foo& foo);
  void RemoveFoo(FooId id);

  // 包装deque迭代器的自定义迭代器
  struct Iterator{
    // 迭代器类型标签，保留随机访问迭代器特性
    using iterator_category = std::random_access_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = Foo;
    using pointer = value_type*;
    using reference = value_type&;

    // 构造函数：接收deque的迭代器
    explicit Iterator(std::deque<Foo>::iterator it) : it_(it){}

    // 前置++
    Iterator& operator++()
    {
      ++it_;
      return *this;
    }

    // 后置++
    Iterator operator++(int)
    {
      Iterator tmp = *this;
      ++it_;
      return tmp;
    }

    // 解引用操作
    reference operator*() const { return *it_; }
    pointer operator->() const { return &(*it_); }

    // 相等/不等判断
    friend bool operator==(const Iterator& lhs, const Iterator& rhs){ return lhs.it_ == rhs.it_; }
    friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { return !(lhs == rhs); }

    // 若需完整随机访问特性，还需实现--、+=、-=、[]等操作，此处保留原示例基础功能
  private:
    std::deque<Foo>::iterator it_; // 内部持有deque迭代器
  };

  // 合法生成begin和end迭代器
  Iterator begin(){ return Iterator(deque_.begin()); }
  Iterator end() { return Iterator(deque_.end()); }

private:
  std::deque<Foo> deque_;
};

关键说明 #

• 自定义迭代器的所有操作转调内部持有的std::deque::iterator，完全遵循标准迭代器行为，不存在未定义行为；
• 外部代码无法直接访问std::deque::iterator，因为它被封装在Iterator的私有成员中，满足“避免暴露内部迭代器”的需求；
• 由于deque迭代器本身支持随机访问，自定义迭代器也能保持std::random_access_iterator_tag的特性，无需额外修改。

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