De retour des références à partir d'une des méthodes C ++

Question

Chers amis, je suis inquiète si je fais une mauvaise utilisation des références en C ++ Dans la GCC méthode suivante avertissement se plaint « référence à la variable locale « moi » de retour »

MatrizEsparsa& MatrizEsparsa::operator+(MatrizEsparsa& outra){
  MatrizEsparsa me(outra.linhas(),outra.colunas());
  return me;
}

Mais, avec les modifications suivantes d'avertissement jusqu'à la disparition:

MatrizEsparsa& MatrizEsparsa::operator+(MatrizEsparsa& outra){
  MatrizEsparsa me(outra.linhas(),outra.colunas());
  MatrizEsparsa &ref = me;
  return ref;
}

La première méthode (retournant la variable 'ref') correct \ acceptable?

Answer 1

Non

. ref fait toujours référence à me qui sera détruit à la fin de l'appel.

Vous devez retourner une copie de votre résultat (non préfixé par &).

MatrizEsparsa MatrizEsparsa::operator+(const MatrizEsparsa& outra) const {
    return MatrizEsparsa(outra.linhas(),outra.colunas());
}

J'ai également ajouté deux spécificateurs const (au paramètre et la méthode) car je doute outra ou l'instance d'appel doivent être modifiés dans ce cas. (Je peux me tromper, mais votre operator+ aurais une sémantique bizarre)

En faisant ce que vous avez fait, vous venez de faire le code plus complexe. Le compilateur était probablement confus et ne pouvait pas vous avertir de votre erreur possible.

En général, lorsque vous devez utiliser des astuces afin de faire des choses simples, cela signifie que quelque chose ne va pas.

Answer 2

Je pense que vous vous trompez vos opérateurs.

Il y a 2:

struct Foo
{
  Foo& operator+=(Foo const&);
  Foo operator+(Foo const&) const;
};

Comme vous le remarquez, les premiers renvoie une référence à lui-même, la seconde ne fonctionne pas.

En outre, en général, le second doit être écrit en fonction libre.

Foo operator+(Foo const&, Foo const&);

Ceci peut être automatisé, parce qu'il est lourd, en utilisant Boost.Operators:

struct Foo: boost::addable<Foo>
{
  Foo& operator+=(Foo const& rhs)
  {
    // add
    return *this;
  }
};

La petite magie boost::addable génère automatiquement la mise en œuvre de + basé sur Foo::operator+=.

Answer 3

Il est pas acceptable. Il est en fait le même problème. Retourner une référence non-const à un objet local qui sera détruit après le retour de la méthode

Answer 4

Non, vous devez retourner une valeur ici, idéalement une valeur const. Voir efficace C ++, point 21.

Je suggère l'interface suivante:

const MatrizEsparsa operator+(const MatrizEsparsa& left, const MatrizEsparsa& right);

Notez que tout est soit une référence const ou une valeur const. De retour une valeur const est pas aussi important que le retour d'une valeur ou de déclarer les paramètres comme références const, mais les arguments de Scott Meyers me ont convaincu, bien que personne ne les suit.

Answer 5

Vous ne pouvez pas renvoyer la référence depuis l'objet que vous faites référence va se détruire hors de votre contrôle. Soit mis « moi » comme une variable membre de MatrizEsparsa afin qu'il persistera après l'exécution de la fonction sinon retourne un pointeur, ou un smart_ptr boost, que les points à l'objet.

Voyant que cela est un opérateur + si, vous voulez probablement retourner une valeur plutôt qu'une référence à une interne variable à la fonction.