C ++ std :: set更新很乏味：我无法就地更改元素

我发现std::set乏味的更新操作是因为cppreference上没有这样的API 。所以我目前正在做的事情是这样的：

//find element in set by iterator
Element copy = *iterator;
... // update member value on copy, varies
Set.erase(iterator);
Set.insert(copy);

基本上，迭代器return bySet是a const_iterator，您不能直接更改其值。

有一个更好的方法吗？或者，也许我应该std::set通过创建自己的方法来覆盖（我不知道它是如何工作的。）

set返回const_iterators（标准说set<T>::iterator是const，这set<T>::const_iterator并set<T>::iterator可能实际上是相同类型的-见23.2.4 / 6在n3000.pdf），因为它是一个有序的容器。如果返回的是常规代码iterator，则可以从容器下方更改项目值，从而可能更改顺序。

您的解决方案是在.NET中更改项目的惯用方式set。

在简单的情况下，有两种方法可以做到这一点：

• 您可以mutable在不属于键的变量上使用
• 您可以将班级分成一Key Value对（并使用std::map）

现在，问题在于棘手的情况：当更新实际上修改key了对象的一部分时会发生什么？您的方法行得通，尽管我承认这很乏味。

在C ++ 17中extract()，由于P0083，您可以做得更好：

// remove element from the set, but without needing
// to copy it or deallocate it
auto node = Set.extract(iterator);
// make changes to the value in place
node.value() = 42;
// reinsert it into the set, but again without needing 
// to copy or allocate
Set.insert(std::move(node));

这将避免您的类型的额外副本和额外的分配/取消分配，并且还将与仅移动类型一起使用。

您也可以extract按键。如果没有密钥，将返回一个空节点：

auto node = Set.extract(key);
if (node) // alternatively, !node.empty()
{
    node.value() = 42;
    Set.insert(std::move(node));
}

更新：尽管到目前为止，以下内容是正确的，但该行为被认为是缺陷，将在即将发布的标准版本中进行更改。真伤心

有几点使您的问题变得令人困惑。

1. 函数可以返回值，而类则不能。std::set是一个类，因此无法返回任何内容。
2. 如果可以打电话s.erase(iter)，那就iter不是const_iterator。erase需要一个非常量迭代器。
3. std::set只要集合也是非常量的，该函数的所有成员函数都将返回迭代器。

只要更新不更改元素的顺序，就可以更改集合中元素的值。以下代码可以编译并正常工作。

#include <set>

int main()
{
    std::set<int> s;
    s.insert(10);
    s.insert(20);

    std::set<int>::iterator iter = s.find(20);

    // OK
    *iter = 30;

    // error, the following changes the order of elements
    // *iter = 0;
}

如果您的更新更改了元素的顺序，则必须擦除并重新插入。

您可能要使用一个std::map代替。使用Element影响键排序的那一部分，并将所有都Element作为值。会有一些次要的数据重复，但是您将拥有更轻松（可能更快）的更新。

我在C ++ 11中遇到了同样的问题，其中确实::std::set<T>::iterator是常量，因此即使我们知道转换不会影响<不变式，也不允许更改其内容。您可以通过将其包装::std::set为mutable_set类型或为内容编写包装器来解决此问题：

  template <typename T>
  struct MutableWrapper {
    mutable T data;
    MutableWrapper(T const& data) : data(data) {}
    MutableWrapper(T&& data) : data(data) {}
    MutableWrapper const& operator=(T const& data) { this->data = data; }
    operator T&() const { return data; }
    T* operator->() const { return &data; }
    friend bool operator<(MutableWrapper const& a, MutableWrapper const& b) {
      return a.data < b.data;
    }   
    friend bool operator==(MutableWrapper const& a, MutableWrapper const& b) {
      return a.data == b.data;
    }   
    friend bool operator!=(MutableWrapper const& a, MutableWrapper const& b) {
      return a.data != b.data;
    }   
  };

我发现这要简单得多，并且在90％的情况下都可以使用，而用户甚至没有注意到集合和实际类型之间存在某些差异。

在某些情况下这会更快：

std::pair<std::set<int>::iterator, bool> result = Set.insert(value);
if (!result.second) {
  Set.erase(result.first);
  Set.insert(value);
}

如果该值通常不在中，std::set则可以具有更好的性能。