如何使集合迭代器的行为像地图迭代器一样？

Question

我有一个类 Foo ，它包含一个 map 并提供 begin() 和 end() 函数进行迭代it：

class Foo {
  typedef std::map<int, double> Container;
  typedef Container::const_iterator const_iterator;
  Container c_;
 public:
  const_iterator begin() const { return c_.begin(); }
  const_iterator end() const { return c_.end(); }
  void insert(int i, double d) { c_[i] = d; }
  // ...

};

现在我想在内部将其从 std::map 更改为 std::set，但我不这样做想要破坏任何客户端代码。

因此，insert 函数中的 double d 现在将被忽略。以下代码应该仍然有效，其中 it->second 现在将始终为 0.0：

Foo foo;
for(Foo::const_iterator it = foo.begin(); it != foo.end(); ++it) {
  std::cout << it->first << " " << it->second << std::endl;
}

如何在 Foo 中进行这些更改代码>类？

换句话说，我如何提供一个 Foo::const_iterator 来适应新的内部 std::set::const_iterator 使其行为像旧的 std::map::const_iterator？

更新：我想摆脱map的原因是内存效率。我有数百万个 Foo 实例，无法在其中存储 double 值。

Answer 1

使用

std::set<std::pair<int, double> >

不足以实现这种可比性吗？

如果失败，您始终可以编写自己的迭代器，它包装 std::list 迭代器并提供 first 和 second 成员。基本上你的operator++会在真正的迭代器等上调用operator++，并且取消引用运算符可以返回一个临时的std::pair（按值）或对存在于迭代器本身内的std::pair的引用（如果你的遗留代码可以处理这个问题）。

更新，稍微做作的示例，可能会根据您的情况起作用：

#include <iostream>
#include <set>

class Foo {
  typedef std::set<int> Container;
  typedef Container::const_iterator legacy_iterator;
  Container c_;

  // legacy iterator doesn't have a virtual destructor (probably?), shouldn't
  // be a problem for sane usage though
  class compat_iterator : public legacy_iterator {
  public:
     compat_iterator(const legacy_iterator& it) : legacy_iterator(it) {
     }

     const std::pair<int,double> *operator->() const {
        static std::pair<int,double> value;
        value = std::make_pair(**this, 0.0);
        // Not meeting the usual semantics!
        return &value;
     }
  };
 public:
  typedef compat_iterator const_iterator;

  const_iterator begin() const { return c_.begin(); }
  const_iterator end() const { return c_.end(); }

};



int main() {

  Foo foo;
  for(Foo::const_iterator it = foo.begin(); it != foo.end(); ++it) {
     std::cout << it->first << " " << it->second << std::endl;
  }

}

Answer 2

像这样的事情怎么样？

#include <iostream>
#include <map>
#include <set>

struct Funky
{
    int first;
    static const double second;

    Funky(int i)
    :   first(i)
    {}
};

const double Funky::second = 0.0;

bool operator<(const Funky& lhs, const Funky& rhs)
{
    return lhs.first < rhs.first;
}

class Foo
{
private:
    //std::map<int,double> m_data;
    std::set<Funky> m_data;
public:
    //typedef std::map<int,double>::const_iterator const_iterator;
    typedef std::set<Funky>::const_iterator const_iterator;

    const_iterator begin() const
    {
        return m_data.begin();
    }

    const_iterator end() const
    {
        return m_data.end();
    }

    void insert(int i, double d)
    {
        //m_data.insert(std::make_pair(i, d));
        m_data.insert(i);
    }
};

int main()
{
    Foo foo;
    foo.insert(23, 9.0);
    for(Foo::const_iterator it=foo.begin(), iend=foo.end(); it!=iend; ++it)
    {
        std::cout << it->first << ' ' << it->second << '\n';
    }
    return 0;
}

Answer 3

也许是某种包装内的东西

operator int()(const std::pair<int, double>& p) const {
    return p.first;
}

？

Answer 4

也许您可以定义一个实现 first 和 second 的 fake_pair 类，并将 set 放入 中>Foo。

Answer 5

你不能，不完全。问题是你正在改变你的界面，这总是会破坏你的客户。我建议您创建两个新函数 newBegin 和 newEnd （或类似的），它们具有您的新行为。您的旧界面保持不变，但将其标记为已折旧。这个旧接口的实现可以使用其他人描述的解决方法之一。