更新std :: map中键的值

Question

Assume we have a simple structure such as the following

struct T{
  int x;
  int y;
};
T t1, t2;

Also assume that I have a map<T, int> myMap and that two structures of type T are compared using their x values only. Ie t1 < t2 iff t1.x < t2.x . I am trying to update some of the y values of the keys over myMap. This should not affect how the map is seeing the keys. Is there any way other than removing the old element and inserting a new one?

Answer 1

If you are sure that y does not participate in the "logical state" of your class and is merely an implementation detail, then you could declare it mutable :

struct T
{
  int x;
  mutable int y;
  bool operator<(const T& rhs) const { return x < rhs.x; }
};

Now you ought to be able to change y :

for (auto it = m.begin(); it != m.end(); ++it)
{
  it->first.y = -2; // ouch? But it won't invalidate the map's invariants.
}

Answer 2

No, map cannot let you modify the keys, because that could invalidate the map invariant (ordering of the elements) — you know it won't, but the map cannot know that, so it errs on the side of caution and disallows that.

Remove and reinsert is a proper way to do it. Treat keys as immutable.

Answer 3

如果y不参与比较，则可以将其标记为mutable ，因此即使值不变也可以修改它。

Answer 4

The keys of std::map are const. So you cannot change it.

Also, if you use only x to compare the keys, then why do you std::map<T,int> ? Why not this:

std::map<int, std::pair<T,int> > data; //where keys would be t.x

After all, in your map, keys are effectively tx .

Answer 5

You can modify T::y if it does not affect comparison operator behaviour. On the other hand it is bad style to modify map's key, it should be immutable. Some implementations of Standard Library do allow to modify key.

Answer 6

键在地图中是常量，尝试将新值复制到新地图中。

Answer 7

Like Cat said you shouldn't change keys for a lot of good reasons but you seem to know enough to move ahead.

Cast away the key's constness with const_cast and you can't do all kinds of damage.... err changes. Just double check that the comparison operator still returns the same after modifying it.