Question

我正在编写一些代码，这些代码基本上可以：

mapSize = map.size();
for(iter=map.begin;iter!=map.end();)
{
  call function which might delete a map item;
  if(map.size()==mapSize )
  {
     iter++;
  }
  else
  {
     mapSize = map.size();
     iter=map.begin(); /* Start again if something was deleted */
  }
}

我认为一定有更好的方法。有什么建议吗？

Answer 1

函数应该为您返回下一个有效的迭代器。这就是映射的正常擦除功能的工作原理。

Answer 2

Map具有一个重要特性，即在映射中插入新元素不会使指向现有元素的迭代器失效。从映射中擦除元素也不会使任何迭代器失效，当然，除了实际指向要擦除的元素的迭代器。

编辑

忘记了这个例子

for(iter=map.begin;iter!=map.end();)
{
  map< type >::iterator itCopy( iter++ );

  // call function which might delete a map item;
  foo( itCopy );
}

Answer 3

最好的办法是

Only have maps of maps and not maps of pointer to maps
Insert objects in them... or shared_ptr

这样，清理将自动为您完成。

Answer 4

首先，调用map.size（）可能会花费很多，所以不要使用太多。

for(iter=map.begin;iter!=map.end();)
{
  current_iter = iter;
 ++iter;
  // call function which might delete a map item;
  my_function(current_iter);
}

Answer 5

我对你的代码有一点考虑。如果你从函数的角度来看待它，我认为你应该重写它，不要使用实际的循环，而是使用一个算法函数，比如remove_If，执行多少次就执行多少次，以处理/删除所有需要的元素。我认为这将导致代码更加清晰，而不必处理for循环的显式初始化。例如，在纯C++中（不是lambda，也不是C++0x，这会使这更容易）：

template <typename I>
class Processor
{
    bool operator(I const& i)
    { // process, return true if it has to be removed
    }
};

然后，在您的代码中：

std::remove_if(map.begin(), map.end(), Processor<Item_type>());

并且在没有移除任何元素时有某种标志可以发现，这样您就可以继续（可能是Processor类的元素）。

Answer 6

I m not too sure what the question is: the title speaks of "maps of maps", but I don t see any in the example code.

Other than that: what should occur if an item was deleted by the function? Do you want to restart the iteration from the start, or continue where you left off (knowing that where you left off might have been removed from the map)? For the first, your code is basically correct, and I don t think that there s a better solution; at least I can t think of one off hand. For the second, I think you d want something like:

iter = map.begin();
while ( iter != map.end() ) {
    key = iter->first;
    //  call function...
    iter = map.upper_bound( key );
}

This is probably the simplest solution. map.upper_bound is O(lg n), however; if the map is large, this could be a problem. Depending on the implementation of map (and the frequency with which your function removes elements), using ++ on the iterator if nothing has been removed from the map might be faster.

Of course, if you can guarantee that the function in question never deletes the element after the one you re at, you can increment the iterator before calling the function. The solution with upper_bound, however, works unconditionally, regardless of what the function changes in the map.

Answer 7

需要知道的一件好事是，带前缀的运算符++返回迭代器的上一个值（副本），并将当前迭代器提升到下一个值。因此，在您的案例中，下一个代码非常有趣：

for (iter = map.begin(); iter != map.end(); )
{
  // call function which might delete the item
  your_function(++iter);

  // and... that s all !
}

这样，如果您通过＜code＞erase＜/code＞falvor在函数中移除参数中的迭代器，则当前迭代器不会因移除而无效，并且您是安全的。

友情链接