Warum bleibt eine temporäre Zeichenfolge gültig, nachdem die Funktion, die sie erstellt hat, zurückkehrt?

Lifetime of Temporaries Revisited

Der in der ursprünglichen Frage bereitgestellte Codeausschnitt zeigt ein scheinbar paradoxes Verhalten, bei dem die von foo() zurückgegebene temporäre Zeichenfolge bleibt auch dann gültig, wenn es angeblich bei der Eingabe von bar() zerstört wurde.

Entgegen der Annahme ist das temporäre Objekt nicht vollständig zerstört, wenn die Funktion, die es erstellt hat, abgeschlossen ist. Stattdessen verlängert sich seine Lebensdauer, bis der gesamte Ausdruck, der das Temporäre enthält, vollständig ausgewertet ist.

Um dieses Konzept zu veranschaulichen, zerlegen wir den Code in seine Komponenten:

• Der temporäre Ausgang ist erstellt in der foo()-Funktion.
• Der Ausdruck foo().c_str() greift dann auf das c_str()-Mitglied von out zu und gibt ein temporäres const char* zurück Zeiger.

Gemäß den C-Sprachregeln bleibt das von foo().c_str() erzeugte const char* temporary bestehen, bis der vollständige Ausdruck bar(foo().c_str()) vollständig ist ausgewertet. Dies bedeutet, dass der Zeiger auch nach Abschluss der Ausführung von foo() gültig bleibt.

Um dieses Verhalten zu visualisieren, stellen Sie sich die folgende Zeitleiste vor:

|--------------------|-----------|-----------|-----------|
|                    | birth    | funeral    |           |
|                    |  ^^^    |  ^^^^     |           |
|--------------------|           |           |           |
|                     | bar()     |           |           |
|                     |           |           |           |
|--------------------|           |           |           |
|                     |           |           |  evaluated |
|                     |           |           |  bar()     |
|--------------------|           |           |           |
|                     |           | foo()      |           |
|                     |           |           |           |
|--------------------|           |           |           |

Die temporären Objekte (der String out und der const char*-Zeiger) werden erstellt, wenn der Ausdruck foo().c_str() ausgewertet wird, und bleiben bestehen, bis der gesamte Ausdruck bar(foo().c_str()) ausgewertet wurde. Dadurch wird sichergestellt, dass der für bar() bereitgestellte Zeiger immer noch gültig ist, wenn die Funktion versucht, auf die Zeichenfolge zuzugreifen.

Daher ist es richtig anzunehmen, dass die von foo() zurückgegebene temporäre Datei nach dem Aufruf von zerstört wird bar() wird abgeschlossen, da dies das Ende des vollständigen Ausdrucks markiert, der das Temporäre enthält.

Das obige ist der detaillierte Inhalt vonWarum bleibt eine temporäre Zeichenfolge gültig, nachdem die Funktion, die sie erstellt hat, zurückkehrt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!