Objets temporaires

Un objet temporaire est un objet sans nom créé par le compilateur pour stocker une valeur temporaire.

Notes

Dans certains cas, il est nécessaire au compilateur de créer des objets temporaires. Ces objets temporaires peuvent être créés pour les raisons suivantes :

• Pour initialiser une const référence avec un initialiseur d’un type différent du type sous-jacent de la référence initialisée.

• Pour stocker la valeur de retour d’une fonction qui retourne un type défini par l’utilisateur (UDT). Ces temporaires sont créés uniquement si votre programme ne copie pas la valeur renvoyée dans un objet. Par exemple :

  UDT Func1();    //  Declare a function that returns a user-defined
                  //   type.
  
  ...
  
  Func1();        //  Call Func1, but discard return value.
                  //  A temporary object is created to store the return
                  //   value.
  

  Étant donné que la valeur de retour n’est pas copiée dans un autre objet, un objet temporaire est créé. Un des cas les plus courants où des objets temporaires sont créés est l'évaluation d'une expression où des fonctions surchargées d'opérateur doivent être appelées. Ces fonctions d’opérateur surchargées retournent un type défini par l’utilisateur qui n’est souvent pas copié dans un autre objet.

  Prenons l'exemple de l'expression ComplexResult = Complex1 + Complex2 + Complex3. L'expression Complex1 + Complex2 est évaluée, et le résultat est stocké dans un objet temporaire. Ensuite, l’expression temporaire+ Complex3 est évaluée et le résultat est copié ComplexResult (en supposant que l’opérateur d’affectation n’est pas surchargé).

• Pour stocker le résultat d'un cast en un type défini par l'utilisateur. Lorsqu'un objet d'un type donné est converti explicitement en un type défini par l'utilisateur, ce nouvel objet est construit sous la forme d'un objet temporaire.

Les objets temporaires ont une durée de vie, définie par leur point de création et le point auquel ils sont détruits. Toute expression qui crée plusieurs objets temporaires les détruit dans l’ordre inverse de création.

Lorsque la destruction d’un événement temporaire dépend de la façon dont elle est utilisée :

• Temporaires utilisés pour initialiser les const références :
  Si un initialiseur n’est pas une valeur l du même type que la référence initialisée, un type d’objet sous-jacent est créé. Il est initialisé par l’expression d’initialisation. Cet objet temporaire est détruit immédiatement après la destruction de l’objet de référence auquel elle est liée. Comme cette destruction peut se produire bien après l’expression qui a créé le temporaire, elle est parfois appelée extension de durée de vie.

• Temporaires créés en tant qu’effet de l’évaluation d’expression :
  Tous les temporaires qui ne tiennent pas dans la première catégorie, et qui sont créés en tant qu’effet de l’évaluation d’expression, sont détruits à la fin de l’instruction d’expression (autrement dit, au point-virgule) ou à la fin des expressions de contrôle pour for, , if, while, doet les switch instructions.

Voir aussi

Blog d’Herb Sutter sur références, simplement