Das Update von C ++ std :: set ist mühsam: Ich kann kein Element an Ort und Stelle ändern

Ich finde den Update-Vorgang std::setmühsam, da es bei cppreference keine solche API gibt . 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 ist der Iterator return by Seta const_iteratorund Sie können seinen Wert nicht direkt ändern.

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

setRückkehr const_iterators(der Standard sagt set<T>::iteratorist const, und dass set<T>::const_iteratorund set<T>::iteratorin der Tat kann die gleiche Art sein - siehe 23.2.4 / 6 in n3000.pdf) , weil es ein geordnete Container ist. Wenn ein regulärer iteratorWert zurückgegeben wird, können Sie den Artikelwert unter dem Container ändern und möglicherweise die Reihenfolge ändern.

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

Im einfachen Fall gibt es zwei Möglichkeiten:

• Sie können mutablefür die Variable verwenden, die nicht Teil des Schlüssels sind
• Sie können Ihre Klasse in ein Key ValuePaar aufteilen (und a verwenden std::map)

Die Frage ist nun für den schwierigen Fall: Was passiert, wenn das Update tatsächlich den keyTeil des Objekts ändert ? Ihr Ansatz funktioniert, obwohl ich zugebe, dass es langweilig ist.

In C ++ 17 können Sie extract()dank P0083 besser damit umgehen :

// 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 Zuordnung / Freigabe und funktioniert auch mit Nur-Verschieben-Typen.

Sie können auch extractper 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));
}

Update: Obwohl das Folgende ab sofort zutrifft, wird das Verhalten als Fehler angesehen und 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::setist eine Klasse und kann daher nichts zurückgeben.
2. Wenn Sie anrufen können s.erase(iter), dann iterist kein const_iterator. eraseerfordert einen nicht konstanten Iterator.
3. Alle Mitgliedsfunktionen std::setdavon geben einen Iterator zurück, der einen nicht konstanten Iterator zurückgibt, solange die Menge ebenfalls nicht konstant ist.

Sie können 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 es löschen und erneut einfügen.

Möglicherweise möchten Sie std::mapstattdessen eine verwenden. Verwenden Sie den Teil, der Elementsich auf die Bestellung des Schlüssels auswirkt, und geben Sie alles Elementals Wert ein. Es wird einige kleinere Daten duplizieren, aber Sie werden einfachere (und möglicherweise schnellere) Updates haben.

Ich bin auf dasselbe Problem in C ++ 11 gestoßen, wo es tatsächlich ::std::set<T>::iteratorkonstant ist und daher keine Änderung des Inhalts zulässt, selbst wenn wir wissen, dass die Transformation die <Invariante nicht beeinflusst . Sie können dies umgehen, indem Sie ::std::seteinen mutable_setTyp einschließen oder einen Wrapper für den Inhalt schreiben:

  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 bemerkt, dass zwischen dem Set und dem tatsächlichen Typ etwas liegt.

Dies ist in einigen Fällen schneller:

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

Wenn der Wert normalerweise noch nicht im Wert ist, std::setkann dies eine bessere Leistung haben.