À propos de la référence constante de retour en C++

Question

Je ne sais pas comment retourner une référence constante en C++. J'ai donc écrit le bloc de code ci-dessous et testé sur gnu c++ et visual studio. Et je trouve des réponses différentes. Quelqu'un pourrait-il me dire quel est l'avantage d'utiliser la référence constante en C++ et la raison pour laquelle le comportement diffère selon le compilateur.

#include <iostream>
using namespace std;

class A
{
public:
    A(int num1, int num2):m_num1(num1), m_num2(num2)
    {
            cout<<"A::A"<<endl;
    }
    const A& operator * (const A & rhs) const
    {
            return A(this->m_num1 * rhs.m_num1, this->m_num2*rhs.m_num1);
    }

    A(const A& rhs)
{
            this->m_num1 = rhs.m_num1;
            this->m_num2 = rhs.m_num2;
            cout<<"A::A(A&)"<<endl;
    }
    const A& operator = (const A& rhs)
    {
            cout<<"A::Operator="<<endl;
            return *this;
    }
    void Display();
private:
    int m_num1;
    int m_num2;
};

void A::Display()
{
    cout<<"num1:"<<m_num1<<" num2:"<<m_num2<<endl;
}

int main()
{
    A a1(2,3), a2(3,4);
    A a3 = a1 * a2;
    a3.Display();
    return 0;
}

Sur Gnu C++, il a signalé la bonne réponse. Mais a échoué sur le compilateur Visual Studion.

Answer 1

Cela renvoie une référence à une variable locale, ce qui n'est pas autorisé :

const A& operator * (const A & rhs) const
{
    return A(this->m_num1 * rhs.m_num1, this->m_num2*rhs.m_num1);
}

Vous avez une référence pendante et un comportement indéfini.

Related

• Renvoi d'une référence constante à une variable locale à partir d'une fonction

Answer 2

 const A& operator * (const A & rhs) const
 {
     return A(this->m_num1 * rhs.m_num1, this->m_num2*rhs.m_num1);
 }

C'est mauvais ici.

Vous renvoyez une référence qui pendouille, si ça marche c'est une coïncidence.

Vous retournez quelque chose qui existe dans un cadre de pile qui a été détruit. Il suffit de retourner par valeur pour le réparer.

Answer 3

const A& operator * (const A & rhs) const
{
    return A(this->m_num1 * rhs.m_num1, this->m_num2*rhs.m_num1);
}

cette fonction vous renvoie une référence à une variable locale. La variable locale sera détruite au retour de cette fonction. operator* . C'est donc dangereux. Vous pouvez juste retourner A mais pas A& .quand le retour A Cette fonction copiera un fichier temporaire A pour le retour.