Bonjour… Ce sujet est en relation avec un autre sujet que j’avais récemment posté sur le forum et intitulé Question sur les references, sujet dont laquelle j’ai commis l’erreur de le mettre résolu prématurément (car je pensais naïvement saisie toute l’étendu des explications de @gbdivers). Ainsi en créant ce nouveau sujet, je ne voulais pas mettre non-résolu puis poser la question apres mettre résolu…
Je vais d’abord exposer ma compréhension ainsi vous pouvez me corriger plus efficacement et en retour espérer
que j’obtiens une réponse complète.
Bref, Il existe encore certaine ambiguïté quant a la différence entre une variable locale et un temporaire. Voici les reformulations que j’ai noté en relisant ces explications :
- Un temporaire est toujours de type constant;
- Par défaut un temporaire a la durée de vie de l’expression et de ses sous-expressions : autrement dit il a la durée de vie de l’instruction et des sous-instructions (comme le cas d’une fonction);
- Il est impossible de faire la conversion implicite d’un
constvers un nonconst; - Si un temporaire est capturé dans une reference, sa durée de vie est étendue a celle de la reference.
Et voici d’autres notes qui ne sont pas en relation avec les explications :
- Une variable locale est une variable qui ne peut être utilisée que dans la fonction
ou bloc dont elle est définie. Autrement toute variable déclarée dans une quelconque
fonction, meme dans la fonction
main, est une variable locale; - Ainsi sa durée de vie est relatif a la fonction/bloc : quand la fonction/bloc se termine, elle disparaît;
- Et peut-être déclarer comme constante ou non.
Je conclus donc qu’un temporaire est normalement limitée a l’expression (instruction) et sous-expressions (sous-instructions) et qu’il est toujours constant alors qu’une variable locale est limitée a la fonction/bloc dont elle est définie et peut être soit constant ou non (différence entre temporaire et variable locale).
#include <iostream>
void fonction (int const & c)
{
std::cout << c << std::endl;
}
int main ()
{
int const a { 0 }; // variable locale constante
std::cout << a << std::endl; // existe tant que la fonction main n'est pas terminee
int b { 1 }; // variable locale non-constante
std::cout << b << std::endl; // existe tant que la fonction main n'est pas terminee
fonction (1234); // temporaire implicitement constant et sa duree limitee ligne 16 et 5
return 0;
}
Les explications @gbdivers ci-dessous font reference au code suivant :
#include <iostream>
int fonction ()
{
int variable { 10 };
return variable;
}
int main ()
{
int const & reference_variable { fonction () };
std::cout << reference_variable << std::endl;
return 0;
}
int const & reference_variable { fonction () }; // #1 std::cout << reference_variable << std::endl; // #2le temporaire retourné par la fonction "fonction" a la ligne #1 ne devrait plus être valide a la ligne #2.
La raison est qu’il existe une règle supplémentaire dont je n’ai pas encore parlé (et je ne me souviens plus si elle est expliquée dans le cours) : l’extension de durée de vie des temporaires ("C++ lifetime extension of a temporary" si tu veux faire une recherche).
En gros, cette règle dit que si un temporaire est "capturé" dans une référence, sa durée de vie est étendue a la durée de vie de la référence.
Dans ton code, la référence est valide a la ligne #2, donc le temporaire est encore valide aussi.
La fonction
fonction ();
ne renvoie pas un temporaire puisque sa valeur de retour n’est pas de type constant (or un temporaire est tjr de type constant). Mais en lisant cette partie de l’explication et en les confrontant aux notes, j’observe une contradiction… Je pense que cette contradiction est du a une mauvaise compréhension de ma part.Donc je vous laisse le soin de m’expliquer mon erreur.
Et enfin, y’a t-il des cas ou il y a confusion entre variable locale et temporaire ? par exemple dans le cas du code suivant :
#include <iostream>
int main ()
{
int const a { 0 };
std::cout << a << std::endl;
return 0;
}
peut-on dire que la variable a,
int const a { 0 };
est a la fois temporaire (puisqu’elle est constante) et locale (puisqu’elle est limitee au bloc main)
???
