C++ std::set update ist mühsam: Ich kann ein Element nicht an Ort und Stelle ändern

Ich finde den Update-Vorgang an std::set mühsam, da es keine solche API gibt cpReferenz. Also, was ich derzeit mache, ist ungefähr so:

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

Grundsätzlich kehrt der Iterator vorbei zurück Set ist ein const_iterator und Sie können seinen Wert nicht direkt ändern.

Gibt es einen besseren Weg, dies zu tun? Oder vielleicht sollte ich überschreiben std::set indem ich mein eigenes erstelle (von dem ich nicht genau weiß, wie es funktioniert..)

set kehrt zurück const_iterators (Die Norm sagt set<T>::iterator ist constund das set<T>::const_iterator und set<T>::iterator kann tatsächlich derselbe Typ sein – siehe 23.2.4/6 in n3000.pdf), da es sich um einen bestellten Container handelt. Wenn es regelmäßig zurückkehrte iteratorkönnten Sie den Artikelwert unter dem Container ändern, wodurch möglicherweise die Reihenfolge geändert wird.

Ihre Lösung ist die idiomatische Art, Elemente in a zu ändern set.

C++17 eingeführt extractsiehe Barrys Antwort.

Wenn Sie mit einer älteren Version festsitzen, gibt es im einfachen Fall 2 Möglichkeiten, dies zu tun:

• Sie können verwenden mutable auf die Variable, die nicht Teil des Schlüssels sind
• Sie können Ihre Klasse in a aufteilen Key Value Paar (und verwenden Sie a std::map)

Nun stellt sich die Frage nach dem kniffligen Fall: Was passiert eigentlich, wenn das Update das ändert key Teil des Objekts? Ihr Ansatz funktioniert, obwohl ich zugeben muss, dass es langweilig ist.

In C ++ 17 können Sie es besser machen mit extract()Dank an 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));

Dies vermeidet eine zusätzliche Kopie Ihres Typs und eine zusätzliche Zuweisung/Aufhebung der Zuweisung und funktioniert auch mit Nur-Verschiebe-Typen.

Du kannst auch extract per Schlüssel. Wenn der Schlüssel fehlt, wird ein leerer Knoten zurückgegeben:

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

Aktualisieren: Obwohl das Folgende ab sofort zutrifft, wird das Verhalten als a Defekt und wird in der kommenden Version des Standards geändert. Wie sehr traurig.

Es gibt mehrere Punkte, die Ihre Frage ziemlich verwirrend machen.

1. Funktionen können Werte zurückgeben, Klassen nicht. std::set ist eine Klasse und kann daher nichts zurückgeben.
2. Wenn Sie anrufen können s.erase(iter)dann iter ist kein const_iterator. erase erfordert einen nicht konstanten Iterator.
3. Alle Mitgliedsfunktionen von std::set die einen Iterator zurückgeben, geben einen nicht konstanten Iterator zurück, solange die Menge ebenfalls nicht konstant ist.

Sie dürfen den Wert eines Elements einer Menge ändern, solange die Aktualisierung die Reihenfolge der Elemente nicht ändert. Der folgende Code wird kompiliert und funktioniert einwandfrei.

#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;
}

Wenn Ihr Update die Reihenfolge der Elemente ändert, müssen Sie sie löschen und erneut einfügen.

Vielleicht möchten Sie eine verwenden std::map stattdessen. Verwenden Sie den Teil von Element das wirkt sich auf die Bestellung des Schlüssels aus und legt alle ab Element als Wert. Es wird einige geringfügige Datenduplizierungen geben, aber Sie werden einfachere (und möglicherweise schnellere) Aktualisierungen haben.

Ich bin in C ++ 11 auf dasselbe Problem gestoßen, wo in der Tat ::std::set<T>::iterator ist konstant und erlaubt daher nicht, seinen Inhalt zu ändern, auch wenn wir wissen, dass die Transformation die nicht beeinflusst < unveränderlich. Sie können dies umgehen, indem Sie wickeln ::std::set in ein mutable_set Geben oder schreiben Sie einen Wrapper für den Inhalt:

  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;
    }   
  };

Ich finde das viel einfacher und es funktioniert in 90% der Fälle, ohne dass der Benutzer überhaupt merkt, dass etwas zwischen dem Satz und dem tatsächlichen Typ liegt.

Das geht in manchen Fällen schneller:

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

Steht der Wert meist nicht schon in der std::set dann kann dies eine bessere Leistung haben.