自定义map迭代器适配不可拷贝值类型的实现问题

你当前在迭代器内缓存pair<const K, V>实体的思路从设计上就不成立，和V是否可拷贝没有直接关系：

1. 你返回的是迭代器内部缓存副本的引用，用户通过迭代器修改值时，改动只会落在副本上，永远不会同步到Map实际存储的vals_数组中，完全不符合map迭代器的核心语义。
2. 你将K、V分开存储在两个独立数组中，内存里根本不存在一个真实的、连续布局的pair<const K, V>对象，自然不可能直接返回该类型的原生引用。

你不需要调整底层键值分离的存储结构，采用代理引用类型实现迭代器即可，这也是C++标准库中std::vector<bool>处理位存储无法返回原生bool引用时的通用实现方案，完全支持不可拷贝、不可移动的V类型。

核心思路是：放弃在迭代器内存储pair实体，转而实现一个轻量代理类，持有当前位置K的const指针和V的指针，模拟pair<const K, V>&的全部行为。所有对代理的读写操作都会直接转发到底层存储的K、V实例上，全程不会发生V的拷贝或移动。

参考实现代码如下：

#include <utility>
#include <cstddef>

template<typename K, typename V>
class Map {
  // 代理引用类型，模拟pair<const K, V>&的行为
  struct ValueProxy {
    const K* first;
    V* second;

    // 支持隐式转换为值类型pair<const K, V>，满足值拷贝场景
    operator std::pair<const K, V>() const {
      return {*first, *second};
    }

    // 重载赋值运算符，直接修改底层存储的值
    ValueProxy& operator=(const std::pair<const K, V>& other) {
      // 标准map不允许通过迭代器修改key，因此这里不处理first的赋值
      *second = other.second;
      return *this;
    }

    // 支持直接给second赋值，和原生pair行为一致
    ValueProxy& operator=(const V& val) {
      *second = val;
      return *this;
    }
  };

public:
  class Iterator {
   public:
    using value_type = std::pair<const K, V>;
    using reference = ValueProxy;
    using pointer = ValueProxy*;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;

    reference operator*() {
      return {&keys_[index_], &vals_[index_]};
    }

    pointer operator->() {
      current_proxy_ = {&keys_[index_], &vals_[index_]};
      return &current_proxy_;
    }

    Iterator& operator++() {
      ++index_;
      return *this;
    }

    Iterator operator++(int) {
      Iterator tmp = *this;
      ++index_;
      return tmp;
    }

    bool operator==(const Iterator& other) const noexcept {
      return index_ == other.index_ && keys_ == other.keys_ && vals_ == other.vals_;
    }

    bool operator!=(const Iterator& other) const noexcept {
      return !(*this == other);
    }

   private:
    int index_ = 0;
    K* keys_ = nullptr;
    V* vals_ = nullptr;
    ValueProxy current_proxy_;
    friend class Map;
    Iterator(int idx, K* keys, V* vals) 
      : index_(idx), keys_(keys), vals_(vals) {}
  };

  Iterator begin() {
    return {0, keys_, vals_};
  }

  Iterator end() {
    return {static_cast<int>(size_), keys_, vals_};
  }

private:
  K* keys_ = nullptr;
  V* vals_ = nullptr;
  size_t size_ = 0;
};

• 全程不会拷贝或移动V类型实例，哪怕V是不可拷贝、不可移动类型，也能正常工作
• 所有读写操作直接作用于Map底层存储，不存在副本不同步的问题
• 代理类仅存储两个指针，额外开销可以忽略，迭代器整体内存占用和你原有实现几乎一致
• 兼容绝大多数常规使用场景，支持(*it).second = xxx、it->second = xxx、auto p = *it等和std::map迭代器一致的写法

注意：该实现属于代理迭代器，如果你需要让迭代器严格满足C++标准对老式迭代器reference必须为原生引用的要求，只能调整底层存储为连续的pair数组。在你无法调整存储结构的前提下，代理迭代器是工业界通用的落地方案，几乎不会在实际业务场景中遇到兼容性问题。

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