Tornando riferimenti da un C ++ metodi

Question

Cari amici, mi riguarda, se sto facendo un cattivo uso di riferimenti in C ++ Nel metodo seguente GCC si lamenta di avvertimento "riferimento alla variabile locale‘me’tornato"

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

Ma, con le seguenti modifiche alla scomparsa di avvertimento:

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

E 'il primo metodo (restituendo la variabile 'ref') corretta \ accettabile?

Answer 1

No. ref riferisce ancora me che sarà distrutto alla fine della chiamata.

Si deve restituire una copia del risultato (non prefisso &).

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

Ho anche aggiunto due identificatori const (per il parametro e al metodo) in quanto dubito outra o chiamando necessità istanza da modificare in questo caso. (Potrei sbagliarmi, ma allora il vostro operator+ avrei uno strano semantica)

Per fare quello che hai fatto, hai appena fatto il codice più complesso. Il compilatore probabilmente era confuso e non si poteva mettere in guardia su un eventuale errore.

Di solito, quando si deve usare trucchi intelligenti per fare le cose semplici, significa che qualcosa non va.

Answer 2

credo che tu stia confondendo gli operatori.

Ci sono 2:

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

Come si nota, i primi restituisce un riferimento a se stessa, la seconda non è così.

Inoltre, in generale, il secondo dovrebbe essere scritto come una funzione libera.

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

Questo può essere automatizzato, perché è ingombrante, usando Boost.Operators:

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

La piccola magia boost::addable genererà automaticamente l'implementazione + sulla base di Foo::operator+=.

Answer 3

Non è accettabile. In realtà è lo stesso problema. Restituisce un riferimento non const a un oggetto locale che verrà distrutto dopo il ritorno del metodo

Answer 4

No, si deve restituire un valore qui, idealmente un valore const. Vedere Effective C ++, punto 21.

Suggerisco la seguente interfaccia:

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

Si noti che tutto ciò che è o un riferimento const o un valore const. Tornando un valore const non è così importante come restituire un valore o dichiarare i parametri come riferimenti const, ma gli argomenti di Scott Meyers mi hanno convinto, anche se nessuno li segue.

Answer 5

Non è possibile restituire il riferimento da quando l'oggetto si fa riferimento andranno distrutte al di fuori del vostro controllo. O mettere "me" come una variabile membro di MatrizEsparsa in modo che possa persistere dopo l'esecuzione della funzione altrimenti restituire un puntatore, o uno smart_ptr impulso, che punti all'oggetto.

Visto che si tratta di un operatore +, però, probabilmente si desidera restituire un valore piuttosto che un riferimento ad una variabile interna alla funzione.