Iterator-Invalidierung durch `std :: string :: begin()`/`std :: string :: end()`?

Question

#include <string> 
#include <iostream> 

int main() { 
    std::string s = "abcdef"; 

    std::string s2 = s; 

    auto begin = const_cast<std::string const &>(s2).begin(); 
    auto end = s2.end(); 

    std::cout << end - begin << '\n'; 
} 

Dieser Code mischt das Ergebnis von begin() const mit dem Ergebnis end(). Keine dieser Funktionen darf Iteratoren ungültig machen. Allerdings bin ich gespannt, ob die Anforderung end(), die Iterator-Variable begin nicht ungültig zu machen, tatsächlich bedeutet, dass die Variable begin mit end verwendbar ist.

Betrachten Sie eine C++ 98, Copy-on-Write-Implementierung von std::string; Die nicht-const begin() und end() Funktionen verursachen, einen internen Puffer zu kopieren, da das Ergebnis dieser Funktionen zu dem Ändern der Zeichenfolge verwandt werden kann. So beginnt begin oben für beide s und s2, aber die Verwendung der nicht-const end() Mitglied verursacht es nicht mehr gültig für s2, der Container, der es produziert.

Der obige Code erzeugt "unerwartete" Ergebnisse mit einer Copy-on-Write-Implementierung, z. B. libstdC++. Anstelle von end - begin ist das gleiche wie s2.size(), libstdC++ produces another number.

• Hat verursacht begin nicht mehr gültig Iterator zu sein in s2, wobei der Behälter aus abgerufen wurde, darstellen ‚Ungültigkeits‘ den Iterator? Wenn Sie sich die Anforderungen für Iteratoren ansehen, scheinen alle für diesen Iterator zu warten, nachdem .end() aufgerufen wurde, so dass sich begin immer noch als gültiger Iterator qualifiziert und somit nicht ungültig gemacht wurde?

• Ist der obige Code in C++ 98 gut definiert? In C++ 11, die Copy-on-Write-Implementierungen verbietet?

Aus meiner eigenen kurzen Lesung der Spezifikationen, scheint es unter festgelegtem, so dass es keine Garantie dafür, dass die Ergebnisse der begin() und end() immer zusammen verwendet werden können, auch ohne const und nicht-Misch konstante Versionen

Answer 1

Wie Sie sagen, C++ 11 unterscheidet sich in dieser Hinsicht von früheren Versionen. In C++ 11 gibt es kein Problem, da alle Versuche, Kopieren beim Schreiben zu erlauben, entfernt wurden. In pre-C++ 11 führt Ihr Code zu undefiniertem Verhalten; Der Aufruf s2.end() darf vorhandene Iteratoren ungültig machen (und tat dies in g ++).

Beachten Sie, dass der Standard, selbst wenn s2 keine Kopie wäre, Iteratoren ungültig machen könnte. Tatsächlich hat die CD für C++ 98 sogar Dinge wie f(s.begin(), s.end()) oder s[i] == s[j] undefiniertes Verhalten gemacht. Dies wurde erst in letzter Minute realisiert und korrigiert, so dass nur der erste Aufruf an begin(), end() oder [] die Iteratoren ungültig machen konnte.

Answer 2

Der Code ist OK: Eine CoW-Implementierung ist ziemlich erforderlich, um die Freigabe aufzuheben, wenn die Gefahr besteht, dass ein Iterator oder ein Verweis auf ein Element gehalten wird. Das heißt, wenn Sie etwas haben, das auf ein Element in einer Zeichenkette zugreift und eine Kopie davon das gleiche tut, d. H. Einen Iterator oder den Subscript-Operator verwendet, muss es freigegeben werden. Es könnte über seine Iteratoren wissen und sie bei Bedarf aktualisieren.

Natürlich ist es in einem gleichzeitigen System fast unmöglich, all dies ohne Datenrennen zu tun, aber vor C++ 11 gibt es keine Datenrennen.

Answer 3

Ab N3337 (which is essentially identical to C++11), liest die Spezifikation ([string.require]/4):

Referenzen, Zeiger und Iteratoren zu den Elementen einer Folge basic_string Bezug kann durch die folgende ungültig gemacht werden, Verwendungen dieses basic_string-Objekts:
[...]
- Aufruf von nicht-const Elementfunktionen, außer operator [], at, front, back, begin, rbegin, end und rend.

Mindestens wie ich es gelesen habe, bedeutet dies, dass ein Aufruf an begin oder end ist keine Iteratoren ungültig zu machen erlaubt. Obwohl nicht direkt angegeben, würde ich dies auch so verstehen, dass kein Aufruf einer const Mitgliedsfunktion Iteratoren ungültig machen kann.

Diese Formulierung bleibt zumindest bis n4296 gleich.

Answer 4

C++ 98 [lib.basic.string]/5 lautet:

Referenzen, Zeiger und Iteratoren zu den Elementen einer Folge basic_string Bezug kann durch die folgenden Verwendungen des Objekts ungültig gemacht werden basic_string :

• als Argument für Drittfunktionen swap(), operator>>() und getline().

• Als ein Argument zu basic_string::swap().

• Aufruf von data() und c_str() Mitgliedsfunktionen.

• Aufruf nicht-const Member-Funktionen, mit Ausnahme operator[](), at(), begin(), rbegin(), end() und rend().

• Im Anschluss an einen der oben genannten Verwendungen mit Ausnahme der Formen des insert() und erase() Iteratoren, die Rückkehr zum ersten Gespräch nicht konstanten Elementfunktionen operator[](), at(), begin(), rbegin(), end() oder rend().

Da der Konstruktor von s2 ist eine „non-const Member-Funktion“, ist es für den Anruf nicht konstante konformen s2.end() - der erste derartige Aufruf pro letzter Kugel oben - Iteratoren ungültig zu machen. Das Programm hat daher kein definiertes Verhalten nach C++ 98.

Ich werde nicht zu C++ 11 kommentieren, da ich denke, dass die anderen Antworten klar erklären, dass das Programm in diesem Kontext Verhalten definiert hat.