Ist string :: c_str () in C ++ 11 nicht mehr null terminiert?

In C ++ 11 basic_string::c_strist genau das gleiche definiert wie basic_string::data, was wiederum genau das gleiche ist wie *(begin() + n)und *(&*begin() + n)(wann 0 <= n < size()).

Ich kann nichts finden, bei dem die Zeichenfolge immer ein Nullzeichen am Ende haben muss.

Bedeutet dies, dass c_str()nicht mehr garantiert wird, dass eine nullterminierte Zeichenfolge erzeugt wird?

Zeichenfolgen sind jetzt erforderlich, um intern nullterminierte Puffer zu verwenden. Schauen Sie sich die Definition von operator[](21.4.5) an:

Benötigt : pos <= size() .

Rückgabe: *(begin() + pos) if pos < size(), andernfalls ein Verweis auf ein Objekt vom Typ Tmit Wert charT(); Der angegebene Wert darf nicht geändert werden.

Rückblickend auf c_str(21.4.7.1/1) sehen wir, dass es definiert ist in Bezug auf operator[]:

Rückgabe: Ein Zeiger p, der p + i == &operator[](i)für jeden iin [0,size()].

Und beide c_strund datamüssen O (1) sein, sodass die Implementierung effektiv gezwungen ist, nullterminierte Puffer zu verwenden.

Wie David Rodríguez - dribeas in den Kommentaren ausführt , bedeutet die Rückgabewertanforderung außerdem, dass Sie &operator[](0)als Synonym für verwenden können c_str(), sodass das abschließende Nullzeichen im selben Puffer liegen muss (da *(p + size())muss gleich sein charT()). Dies bedeutet auch, dass selbst wenn der Terminator träge initialisiert wird, es nicht möglich ist, den Puffer im Zwischenzustand zu beobachten.

Tatsächlich stimmt der neue Standard, dass .data () und .c_str () jetzt Synonyme sind. Es heißt jedoch nicht, dass .c_str () nicht mehr nullterminiert ist :)

Es bedeutet nur, dass Sie sich jetzt darauf verlassen können, dass .data () auch mit Null abgeschlossen wird.

In Artikel N2668 werden die Mitglieder c_str () und data () von std :: basic_string wie folgt definiert:

 const charT* c_str() const; 
 const charT* data() const; 

Rückgabe: Ein Zeiger auf das Anfangselement eines Arrays der Länge size () + 1, dessen erste size () -Elemente den entsprechenden Elementen der von * this gesteuerten Zeichenfolge entsprechen und dessen letztes Element ein durch charT () angegebenes Nullzeichen ist.

Erforderlich: Das Programm darf keinen der im Zeichenarray gespeicherten Werte ändern.

Beachten Sie, dass dies NICHT bedeutet, dass ein gültiger std :: string als C-String behandelt werden kann, da std :: string eingebettete Nullen enthalten kann, die den C-String vorzeitig beenden, wenn sie direkt als const char * verwendet werden.

Nachtrag:

Ich habe keinen Zugriff auf die tatsächlich veröffentlichte endgültige Spezifikation von C ++ 11, aber es scheint, dass der Wortlaut tatsächlich irgendwo im Revisionsverlauf der Spezifikation gestrichen wurde: z. B. http://www.open-std.org/jtc1/ sc22 / wg21 / docs / papers / 2011 / n3242.pdf

§ 21.4.7 String-Operationen basic_string [string.ops]

§ 21.4.7.1 basic_string-Accessoren [string.accessors]

     const charT* c_str() const noexcept;
     const charT* data() const noexcept;

1. Rückgabe: Ein Zeiger p, so dass p + i == &operator[](i)für jeden iin [0,size()].
2. Komplexität: konstante Zeit.
3. Erforderlich: Das Programm darf keinen der im Zeichenarray gespeicherten Werte ändern.

Die "Geschichte" war, dass vor langer Zeit, als alle in einzelnen Threads arbeiteten oder zumindest die Threads Arbeiter mit ihren eigenen Daten waren, sie eine String-Klasse für C ++ entwarfen, die die Handhabung von Strings einfacher machte als zuvor, und sie überlasteten Operator + zum Verketten von Zeichenfolgen.

Das Problem war, dass Benutzer so etwas tun würden:

s = s1 + s2 + s3 + s4;

und jede Verkettung würde eine temporäre erzeugen, die eine Zeichenfolge implementieren musste.

Daher hatte jemand die Gehirnwelle der "faulen Auswertung", so dass Sie intern eine Art "Seil" mit allen Zeichenfolgen speichern konnten, bis jemand es als C-Zeichenfolge lesen wollte. An diesem Punkt würden Sie die interne Darstellung in einen zusammenhängenden Puffer ändern .

Dies löste das obige Problem, verursachte jedoch eine Menge anderer Kopfschmerzen, insbesondere in der Multithread-Welt, in der erwartet wurde, dass eine .c_str () -Operation schreibgeschützt ist / nichts ändert und daher nichts gesperrt werden muss. Vorzeitiges internes Sperren in der Klassenimplementierung für den Fall, dass jemand Multithreading durchführte (wenn es nicht einmal einen Threading-Standard gab), war ebenfalls keine gute Idee. Tatsächlich war es teurer, dies zu tun, als jedes Mal einfach den Puffer zu kopieren. Der gleiche Grund, warum die Implementierung "Beim Schreiben kopieren" für Zeichenfolgenimplementierungen abgebrochen wurde.

Daher .c_str()stellte sich heraus, dass es am sinnvollsten ist , eine wirklich unveränderliche Operation durchzuführen. Könnte man sich jedoch in einem Standard, der jetzt Thread-fähig ist, darauf "verlassen"? Aus diesem Grund hat der neue Standard entschieden, dass dies eindeutig möglich ist, und daher muss die interne Darstellung den Nullterminator enthalten.

Gut erkannt. Dies ist sicherlich ein Fehler in der kürzlich verabschiedeten Norm; Ich bin sicher, dass es nicht die Absicht gab, den gesamten aktuell verwendeten Code zu brechen c_str. Ich würde einen Fehlerbericht vorschlagen oder zumindest die Frage stellen comp.std.c++(die normalerweise vor dem Ausschuss landet, wenn es sich um einen Fehler handelt).