De retour à la référence const variable locale d'une fonction

Question

J'ai quelques questions sur le retour d'une référence à une variable locale d'une fonction:

class A {
public:
    A(int xx)
    : x(xx)
    {
        printf("A::A()\n");
    }
};

const A& getA1()
{
    A a(5);
    return a;
}

A& getA2()
{
    A a(5);
    return a;
}

A getA3()
{
    A a(5);
    return a;
}

int main()
{
    const A& newA1 = getA1(); //1
    A& newA2 = getA2(); //2
    A& newA3 = getA3(); //3
}

Mes questions sont =>

1. La mise en œuvre de getA1() correcte? Je pense qu'il est incorrect car il retourne l'adresse d'une variable locale ou temporaire.

2. Lequel des énoncés dans main (1,2,3) conduira à un comportement non défini?

3. Dans const A& newA1 = getA1(); ne la garantie standard temporaire lié par une référence const ne sera pas détruit jusqu'à ce que la référence est hors de portée?

Answer 1

  

1. Est mise en œuvre de getA1() correcte? Je pense qu'il est incorrect car il retourne l'adresse de la variable locale ou temporaire.

La seule version de getAx() qui est correct dans votre programme est getA3(). Les deux autres ont un comportement non défini, peu importe la façon dont vous les utiliser plus tard.

  

2. Lequel des énoncés dans les principaux (1,2,3) conduira à un comportement non défini?

Dans un sens, aucun d'entre eux. Pour 1 et 2, le comportement non défini est à la suite des corps des fonctions. Pour la dernière ligne, newA3 doit être une erreur de compilation que vous ne pouvez pas lier temporaire à une référence non const.

  

3. En const A& newA1 = getA1(); ne garantit standard que temporaire liées par un const   référence ne sera pas détruit jusqu'à ce que la référence est hors de portée?

Non. Voici un exemple de ce qui suit:

A const & newConstA3 = getA3 ();

Ici, getA3() retourne temporaire et la durée de vie de cette temporaire est maintenant lié à l'newConstA3 d'objet. En d'autres termes, le temporaire existera jusqu'à ce que newConstA3 est hors de portée.

Answer 2

Q1:. Oui, cela est un problème, voir la réponse à Q2

Q2: 1 et 2 ne sont pas définis comme ils font référence à des variables locales sur la pile de getA1 et getA2. Ces variables sont hors de portée et ne sont plus disponibles et le pire peuvent être écrasées lorsque la pile est en constante évolution. getA3 fonctionne depuis une copie de la valeur de retour est créé et renvoyé à l'appelant.

Q3: Une telle garantie existe pour voir la réponse à Q2

.

Answer 3

Je pense que le principal problème est que vous n'êtes pas du tout retournerez temporaires, vous devriez

return A(5);

plutôt que

A a(5);
return a;

Sinon, vous retournez l'adresse variable locale, et non temporaire. Et le temporaire à Const référence ne fonctionne que pour les temporaires.

Je pense que son expliqué ici: temporaire à Const référence

Answer 4

Si vous compilez cela sur VC6 vous obtiendrez cet avertissement

****** compilateur d'avertissement (niveau 1) C4172 adresse de retour de la variable locale ou temporaire Une fonction retourne l'adresse d'un objet variable temporaire ou local. Les variables locales et les objets temporaires sont détruits quand un retour de la fonction, de sorte que l'adresse de retour est pas valide. ******

Lors du test pour ce problème que j'ai trouvé chose intéressante (le code donné travaille en VC6):

 class MyClass
{
 public:
 MyClass()
 {
  objID=++cntr;
 }
MyClass& myFunc()
{
    MyClass obj;
    return obj;
}
 int objID;
 static int cntr;
};

int MyClass::cntr;

main()
{
 MyClass tseadf;
 cout<<(tseadf.myFunc()).objID<<endl;

}