Pourquoi une chaîne temporaire reste-t-elle valide après le retour de la fonction qui l'a créée ?

La durée de vie des temporaires revisitée

L'extrait de code fourni dans la question d'origine démontre un comportement apparemment paradoxal où la chaîne temporaire renvoyée par foo() reste valide même après avoir été prétendument détruit lors de la saisie de bar().

Contrairement à l'hypothèse, l'objet temporaire n'est pas entièrement détruit lorsque la fonction qui l'a créé est terminée. Au lieu de cela, sa durée de vie s'étend jusqu'à ce que l'expression entière qui contient le temporaire soit entièrement évaluée.

Pour illustrer ce concept, décomposons le code en ses composants :

• Le temporaire est créé dans la fonction foo().
• L'expression foo().c_str() accède ensuite au membre c_str() de out et renvoie un const char* temporaire pointeur.

Selon les règles du langage C, le const char* temporaire produit par foo().c_str() persistera jusqu'à ce que la barre d'expression complète (foo().c_str()) soit complètement évalué. Cela signifie que le pointeur reste valide même après la fin de l'exécution de foo().

Pour visualiser ce comportement, imaginez la chronologie suivante :

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

Les objets temporaires (la chaîne et le pointeur const char*) sont créés lorsque l'expression foo().c_str() est évaluée, et ils persistent jusqu'à ce que l'expression entière bar(foo().c_str()) ait été évaluée. Cela garantit que le pointeur fourni à bar() est toujours valide lorsque la fonction tente d'accéder à la chaîne.

Par conséquent, il est correct de supposer que le temporaire renvoyé par foo() sera détruit après l'appel à bar() se termine, car cela marque la fin de l'expression complète qui contient le temporaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!