C++ std::set update ist mühsam: ich kann nicht ändern, ein element in place

Finde ich die update-operation auf std::set mühsam, da es keine solche API auf cppreference. Also, was ich derzeit tun, ist so etwas wie dieses:

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

Grundsätzlich der iterator zurück von Set ist ein const_iterator und Sie können nicht ändern, seinen Wert direkt.

Gibt es einen besseren Weg, dies zu tun? Oder vielleicht sollte ich überschreiben std::set durch meinen eigenen (was ich nicht genau weiß, wie es funktioniert..)

Eine inline-Funktion, wenn Sie finden über 2 Aussagen ist schon mühsam.
KennyTM trifft den Nagel auf den Kopf. Es gibt keine Nachteile performancewise, um dies zu tun, so tun Sie es einfach jetzt schon! 😛
Wenn Sie schreiben, eine update-Funktion, möchten Sie vielleicht, um das Modell auf die gleiche Weise, wie Boost.MultiIndex: boost.org/doc/libs/release/libs/multi_index/doc/tutorial/...
cplusplus.com ist eine schreckliche Referenz. Finden Aspekte der Sprache "langweilig", weil es scheint... seltsam.
Ich denke der Nachteil dieses Ansatzes ist, wobei ein Lese/Schreib-Sperre im Fall der gleichzeitigen Verarbeitung.

InformationsquelleAutor Figo | 2010-02-07

c++set stl

72

set zurück const_iterators (der standard sagt set<T>::iterator ist const, und dass set<T>::const_iterator und set<T>::iterator kann in der Tat die gleichen Typ - siehe 23.2.4/6 in n3000.pdf), weil es einen bestellten container. Wenn es wieder eine regelmäßige iterator, würden Sie erlaubt werden, ändern Sie die Elemente mit dem Wert aus dem Behälter, potenziell änderung der Bestellung.

Ihre Lösung ist die idiomatische Weise zu verändern, die Elemente in einer set.
- Mitglieder (nicht-const) std::set nicht zurück const_iterator und Sie kann ändern Sie die Elemente, wenn du vorsichtig bist. Warum ist diese (falsche) Antwort immer so viele upvotes? Was bin ich?
- Meine Antwort ist richtig, deine ist falsch. Ich habe meinen Beitrag aktualisiert mit Referenzen auf die Norm.
- Terry, ich danke Ihnen für die Diskussion. Ich habe geprüft: die Mangel-Bericht hatte zwar schon vorgelegt, im Jahr 1998, wurde aber nicht eingearbeitet in C++03. Es wird in C++0x. So, während Ihre Antwort ist nicht richtig so weit wie der aktuelle Brief von der Norm betroffen ist, ist es korrekt, soweit die Absicht geht. +1.
- Vielen Dank für Ihren Kommentar und Ihre Debatte mit Avakar (Oder Avatar?). Sie viel geholfen.
- Die Elemente sind technisch verändert, aber es ist nicht erlaubt, Sie zu verändern. Dies ist ein Mangel in der Norm.
- Also denke ich, dass der richtige Weg, veränderliche Teile, die mit eindeutigen Schlüsseln, während immer noch mit STL, ist der Wechsel zu std::map. Das ist, was ich getan habe, sowieso
- Ja, natürlich. Beide set und map müssen unveränderlich Schlüssel, und wenn Sie nicht-Schlüssel-Felder, die Sie ändern möchten, diese sollte den Wert Teil einer map. (Ich muss Optionen, wie mit der mutable Mitglieder in set Elemente: igitt)
InformationsquelleAutor Terry Mahaffey
22

Gibt es 2 Möglichkeiten, dies zu tun, in der einfache Fall:
- Können Sie mutable auf die variable, die nicht Teil des Schlüssels
- Teilen Sie Ihre Klasse in eine Key Value - pair-Mädchen (und verwenden Sie ein std::map)
Nun, die Frage ist für den kniffligen Fall: was passiert, wenn das update ändert die key Teil des Objekts ? Dein Ansatz funktioniert, obwohl ich zugeben, es ist mühsam.
- +1 veränderlich auf einem nicht-Schlüssel-Element ist eine tolle Idee,
- hinzufügen von Mutationen auf einem nicht-Schlüssel-Mitglied wäre ok, wenn Ihr einige interne/private Klasse, aber seine immer noch ein dirty hack! Sobald die Klasse ausgesetzt ist, einige Benutzer, id nie Wagen, Sie zu benutzen veränderlich für Mitglieder, die nicht dazu gedacht sind, veränderlich! Das ist böse!
InformationsquelleAutor Matthieu M.
8

Update: Obwohl das folgende gilt jetzt, das Verhalten wird als eine defekt und wird geändert werden in der kommenden version des Standards. Wie sehr traurig.

Gibt es mehrere Punkte, die Ihre Frage ziemlich verwirrend.
1. Funktionen können Werte zurückgeben, können Klassen nicht. std::set ist eine Klasse, und kann deshalb nicht etwas zurückzugeben.
2. Wenn Sie anrufen können s.erase(iter), dann iter ist nicht ein const_iterator. erase erfordert eine nicht-const-iterator.
3. Alle member-Funktionen von std::set, die zurück einen iterator zurückgeben, einen nicht-const-iterator solange das set ist non-const-als auch.
Dürfen Sie zum ändern des Werts eines Elements in einem Satz, solange das update nicht die Anordnung der Elemente ändern. Der folgende code kompiliert und funktioniert Prima.
```
#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 ändert die Reihenfolge der Elemente, dann Sie haben zu löschen und wieder einzufügen.
- Dass der code nicht kompilieren, zumindest in der VC10 - für die Gründe habe ich dargestellt in meinem post. Dies kann in letzter Zeit geändert haben (ein "bug-fix" der standard), ich dachte, es wurde in C++03, aber ich könnte falsch sein.
- Naja, ich freu mich auf 23.1.2[lib.assoziatives.Bestand] von C++03, Tabelle 69 und er sagt: "ein.find(k): iterator; const_iterator für eine Konstante".
- Und ich habe gerade überprüft den Entwurf für C++0x und es ist keine änderung (was nicht verwunderlich ist, und es brechen würde viel code).
- Ich habe nicht die C++03 pdf handy (es kostet Geld). Ich dachte, dies wurde behoben in C++03, aber es hätte ein post 03 fix. In n3000.pdf-es ist 23.2.4/6, die erklärt, dass für assoziative Container, iterator ist ein const iterator (und kann von demselben Typ sein, const_iterator). Welchen compiler benutzt du? Dieses Verhalten wurde implementiert, in VC9 (die war tracking C++03), weshalb ich dachte, das Verhalten wurde in ein C++03-bug-fix.
- Schauen Sie nicht auf die Tabelle, schau auf den Absatz erklären Sie sich den Anforderungen des "iterator" auf einem assoziativen container. Ein iterator kann "const", ohne tatsächlich den Namen "const_iterator".
- Recht, obwohl das ein Wechsel von C++03, wo 23.1.2/6 (das entspricht 23.3.4/6 in C++0x) sagt nur "iterator von einem assoziativen container ist der bidirektionale iterator-Kategorie." Ich habe gebaut, das snippet mit msvc9 ohne Probleme, so ist es in der Tat track C++03.
- Es ist in der Standard-library-Fehler: open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103. Es wird nicht kompiliert mit GCC, das macht eine Erwähnung von DR 103 und die beiden typedefs iterator und const_iterator der gleiche Typ. - Eine vorgeschlagene Problemumgehung für OP ' s Probleme, BTW, sind const_cast und veränderlich Mitglieder.
- +1 für die interessante Diskussion in den Kommentaren
- haben Sie bemerkt, dass für Karten, C++03 gibt den Wert an, der Typ ist pair<const Key, T>. Auf dieser Grundlage dürfen, ändern Sie die set-Taste scheint wie ein versehen, dass der C++0x-Ausschuss fest.
- was passiert in MSVC 9 wenn Sie das tun *iter = 0;? Hat der Betrieb zu werfen? Tut es ermöglicht die Bedienung aber zu Problemen im weiteren Gebrauch der container?
- ja, ich habe die DR auch. Ich bin ein wenig überrascht, dass es es nicht in C++03 war aber eingebunden in den aktuellen Entwurf. Es ist ein eher schwerer ändern, aus meiner Sicht, da es sonst brechen richtigen code.
- Samuel Klatchko, es kompiliert und läuft Prima, aber es wird wahrscheinlich brechen irgendwo auf der ganzen Linie.
InformationsquelleAutor avakar

In C++17, die Sie tun können, besser mit extract(), Dank 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));

Dadurch vermeiden Sie eine zusätzliche Kopie Ihrer Art und eine extra allocation/deallocation, und auch mit move-nur Typen.

Können Sie auch extract durch Schlüssel. Wenn der Schlüssel nicht vorhanden ist, wird das Ergebnis eine leere Knoten:

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

InformationsquelleAutor Barry

7

Die Sie möglicherweise verwenden möchten, ein std::map statt. Verwenden Sie den Teil der Element betrifft die Bestellung der Schlüssel, und alle Element als Wert. Wird es einige kleinere die Duplizierung der Daten, aber haben Sie einfacher (und wahrscheinlich schneller) aktualisiert.

InformationsquelleAutor
2

Begegnete ich das gleiche Thema in C++11, wo in der Tat ::std::set<T>::iterator ist konstant und somit nicht erlaubt, den Inhalt ändern, auch wenn wir wissen, dass die transformation nicht auf die < invariant. Sie können dies umgehen, indem er ::std::set in eine mutable_set geben, oder schreiben Sie ein 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 auch merken das es etwas zwischen der eingestellten und der tatsächlichen Typ.
- Interessante Idee, ich werde versuchen, denken Sie daran diese.
- Ja, aber nur, um zusätzliche sicher sein, dass, es sollte angemerkt werden, dass diese darf nur verwendet werden, wenn die änderung der gespeicherten Daten hinter dem iterator garantiert nicht zum ändern der Reihenfolge des Satzes. Anders ist das UB, und es wird Pause! (Wiederholen einfach nur das, um sicher sein, dass niemand schießt sich selbst in den Fuß. Ich bin nicht sagen, Sie insbesondere nicht erkannt.)
- +1 das ist ideal, wenn Sie wollen einzigartige sortiert Elemente, basierend auf einige der wichtigsten (für welches set ist das richtige Gefäß), aber wollen auch, dass einige 'Metadaten' mit Ihnen die ändern kann
- Dieser Ansatz funktioniert nicht auf meinem Objekt. Speziell auf Zeiger-operator-like " - operator-> ()", wenn ich versuche zu nennen, meine Klasse Methode.
InformationsquelleAutor bitmask
0

Dies ist schneller, in einigen Fällen:
```
std::pair<std::set<int>::iterator, bool> result = Set.insert(value);
if (!result.second) {
  Set.erase(result.first);
  Set.insert(value);
}
```
Wenn der Wert in der Regel nicht schon in der std::set dann kann dies die bessere Leistung.

InformationsquelleAutor jcoffland

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.