2

假设你有一个

std::unordered_set<std::shared_ptr<A>> as;
// (there is an std::hash<std::shared_ptr<A>> specialisation)

并且您想在迭代它时替换它的一些元素：

for (auto it = as.begin(); it != as.end(); ++it) {
  if ((*it)->condition()) {
    as.erase(it);
    as.insert(std::make_shared<A>(**it));
  }
}

这可能会使迭代器在eraseand处无效insert（如果发生重新散列），因此此循环将表现出未定义的行为，并且很可能会严重崩溃。

我能想到的一种解决方案是使用两个单独vector的 s 来缓冲insertanderase操作，然后使用采用迭代器对进行擦除和插入的重载（这可能对重新散列更友好）。

即使我使用缓冲区方法，这仍然看起来是臃肿的代码，并且可能导致两次重新散列，这可能都是不必要的。

那么，有没有更好的方法呢？

4

4 回答 4

1

我只是想到了一种可能的方法（在询问之后），但也许还有更好的方法。

将所有内容复制到向量，然后从向量重建集合应该更快：

std::vector<std::shared_ptr> buffer;
buffer.reserve(as.size());
for (auto it = as.begin(); it != as.end(); ++it) {
  if ((*it)->condition()) {
    buffer.push_back(std::make_shared<A>(**it));
  } else {
    buffer.push_back(*it);
  }
}
as = std::unordered_set<std::shared_ptr<A>>(buffer.begin(),buffer.end());
于 2012-09-30T11:54:36.463 回答
1

当您调用as.erase(it)迭代器时，它会it失效。插入无序关联容器会使所有迭代器无效。因此，插入需要与迭代器分开。避免插入对于避免处理新插入的对象也是必要的：

std::vector<std::shared_ptr<A>> replaced;
for (auto it = as.begin(); it != as.end(); ) {
    if ((*it)->condition()) {
        replaced.push_back(std::make_shared<A>(**it));
        as.erase(it++);
    }
    else {
        ++it;
    }
}
std::copy(replaced.begin(), replaced.end(), std::inserter(as, as.begin());
于 2012-09-30T11:55:35.947 回答
0

我会将其作为对@bitmask 答案的评论。为什么不将向量用于替换元素？

std::vector<decltype(as)::value_type> buffer;
buffer.reserve(as.size());
for (auto it = as.begin(); it != as.end(); )
{
  if ((*it)->condition())
  {
    buffer.push_back(*it);
    it = as.erase(it);
  }
  else
  {
    ++it;
  }
}
as.insert(buffer.begin(),buffer.end());

而且，如果*it已经是shared_ptr<A>，我再也找不到理由make_shared()了。只需分配并让复制构造函数/赋值运算符发挥他们的魔力。

于 2017-03-22T16:51:38.290 回答
-1

在你的情况下，你可以在我看来交换：

for(auto iter = as.begin(); iter != as.end(); ++iter)
{
    if(/*Check deletion condition here*/)
    {
        auto newItem = std::make_shared<A>(/*...*/);
        swap(*iter, newItem);
    }
}
于 2012-12-15T22:38:36.400 回答