Indirizzo del valore di ritorno del metodo

Question

ho un get-metodo che restituisce un valore:

int Foo::getValue() const 
{ 
    return value_; 
} 

Sto utilizzando il seguente codice di scrivere questo valore in un file binario:

void Bar::write(const Foo& foo) 
{ 
    /* some code... */ 

    file_.write(reinterpret_cast<char*>(&foo.getValue()), sizeof(int)); 
} 

E sembra che tutto funzioni bene. Ma non sono sicuro di quello & foo.getValue() cosa. Restituirà sempre un indirizzo di valore di ritorno di getValue() o ci sono delle insidie?

EDIT1: Non voglio creare una var temporanea per questo.

EDIT2: Sì, compila e funziona correttamente.

Edit3: scrittura è un ostream :: scrivere

edit4: Con/parete e/Za non si compila: Errore C2102: '&' richiede l-value

Answer 1

Lo standard vieta di prendere l'indirizzo di un valore: https://stackoverflow.com/a/28459180/2642059 Un compilatore che non è conforme allo standard può consentire questo comportamento, ma sicuramente non è un comportamento che sarà multipiattaforma, né è garantito il successo anche tra gli aggiornamenti al compilatore che potrebbero allineare strettamente con lo standard C++.

Poiché non si sta programmando per un compilatore specifico, ma per C++, trovare qualcosa che funzioni in uno specifico compilatore non dovrebbe essere il vostro obiettivo. Sarebbe preferibile trovare un modo per realizzare questo all'interno dello standard.

Un paio di semplici opzioni per fare questo sarebbe:

1. trasformarlo in un lvalue assegnandolo ad un valore temporaneo. Sono gratis! Il compilatore li ottimizzerà immediatamente
2. Modificare la restituzione di getValue a const int& questo consentirà di lavorare con un lvalue. Dal int s sono in genere copiati per valore questo probabilmente non avrà ripercussioni nel vostro codice di base, ma potrebbe
3. Creare un altro metodo che potrebbe tornare direttamente (const char*)&value_, si potrebbe finire nei guai abusare di questo però, quindi state attenti

Answer 2

Microsoft Compiler per qualsiasi motivo ha una "funzione" - converte implicitamente in temporaneo in lvalue. Puoi controllare con questo codice:

int &ref = foo.getValue(); 

questo codice così come il tuo non dovrebbe compilare. codice appropriato sarebbe:

void Bar::write(const Foo& foo) 
{ 
    /* some code... */ 
    int temp = foo.getValue(); 
    file_.write(static_cast<const char*>(&temp), sizeof(int)); 
}