Wie die Adresse des Rückgabewert einer Funktion in C++

Question

Vor diesem Prototyp erhalten, die eine Endian Konvertierung tut:

time_t Flip(time_t); 

Ich möchte den Rückgabewert in einer Funktion verwenden, die eine BYTE nimmt * als ein Argument. Etwas wie folgt aus:

SetBytesAt(0, (BYTE*)&(Flip(t))); 

Aber dies nicht kompiliert. Gibt mir diesen Fehler "& erfordert l-Wert". Wenn die Funktion() um die Flip-Funktion herum entfernt wird, wird derselbe Fehler generiert.

Nun, ich weiß, dass ich dies nur tun können:

time_t temp_t = Flip(t); 
SetBytesAt(0, (BYTE*)&temp_t); 

Aber es scheint mir, dass ich in der Lage sein sollte, die gleiche Sache, ohne die temporären temp_t Variable zu erreichen.

Answer 1

Leider nein. Sie können nicht die Adresse eines temporären (richtiger, ein r-value) nehmen. So wurde die Sprache definiert.

Answer 2

Sie müssen eine temporäre Variable verwenden. Sie können nur Adresse von l-Werten nehmen. Es gibt keine Möglichkeit, die Adresse eines Rückgabewerts zu ermitteln.

Bei einigen Plattformen wird der Rückgabewert nur in einem Register gespeichert und hat daher nicht einmal eine Adresse. Sie müssen es im Speicher speichern, bevor Sie seine Adresse an eine andere Funktion übergeben können.

Answer 3

Soweit ich weiß, ist das in C++ nicht möglich.

Fragen Sie sich dies: Wie erhalten Sie Zugriff auf das modifizierte Ergebnis nach SetBytesAt zurückgibt?

Rückgabewerte werden normalerweise in eine tatsächliche Variable in der Aufruferfunktion kopiert (oder verschoben). Der für den zurückgegebenen Wert reservierte temporäre Speicherbereich ist nicht mehr verfügbar, nachdem die Funktion zurückgegeben wurde. Theoretisch würden Sie Speicher stapeln, der nicht mehr gültig ist. Dieser Fehler tritt in der Praxis auf, wenn Referenzen auf lokale Variablen zurückgegeben werden.

Answer 4

Sie können nicht, für den genauen Grund durch die Fehlermeldung angegeben - & requires l-value.

Der Aufruf Flip(t) ist kein l-Wert, also ist es unmöglich.

Answer 5

Versuchen Sie das nicht zu Hause.

template <typename T> 
class AddressableTemporary 
{ 
public: 

    AddressableTemporary(T const value) 
     : value_(value) 
    { 
    } 

    operator T*() { return &value_; } 

private: 

    T value_; 
}; 

template <typename T> 
AddressableTemporary<T> MakeAddressable(T value) 
{ 
    return AddressableTemporary<T>(value); 
} 

als:

int F() { return 42; } 
void G(int const* const p) { std::cout << *p; } 

int main() 
{ 
    G(MakeAddressable(F())); 
} 

Aber wirklich, tun dies nicht. Verwenden Sie entweder eine Variable oder schreiben Sie eine Wrapper-Funktion, die die Verwendung der Variablen kapselt, oder bearbeiten Sie Ihren Code neu, sodass Sie sich keine Gedanken darüber machen müssen (z. B. die Funktion so ändern, dass sie beispielsweise eine const-Referenz benötigt).

Answer 6

Eigentlich wurde es in C++ 11 möglich. Dort wurden r-Wert-Referenzen eingeführt. Ich weiß jedoch nicht, welcher Compiler das schon tut.

Answer 7

Es ist keine große Sache zu tun, was Sie wollen, aber es ist unrein.

geht hier:

template< class Type > 
Type const& ref(Type const& v) { return v; } 

int main() 
{ 
    time_t t = blah blah; 
    SetBytesAt(0, const_cast<Byte*>(reinterpret_cast<Byte const*>(&ref(Flip(t))))); 
} 

Technisch kann dies funktionieren, wenn SetBytesAt kopiert das Bytes, aber wenn SetBytesAt speichert den Zeiger, und der Zeiger später verwendet wird, dann ist es nicht definiertes Verhalten.

Wie auch immer, tun Sie das nicht.

Jetzt werde ich Liste, was mit dem ursprünglichen Konzept falsch ist:

• Typ Wissen Wegwerfen von typenlos Zeiger Argument.
  → Bedeutet viel zusätzliche Arbeit, weil der Typ nicht bekannt ist.

• Verwerfen von const-Wissen durch Verwendung des Zeigers auf nicht-konstantes Argument.
  → Bedeutet viel zusätzliche Arbeit, weil die Konstanz nicht bekannt ist.

• Spiegeln Byte Reihenfolge der Daten = nicht gut außer in Low-Level-Netzwerk-Code.
  → Bedeutet viel zusätzliche Arbeit, weil die Byte-Reihenfolge nicht bekannt ist.

Also, wieder, tu das nicht.

Stattdessen das Gegenteil tun: Typ Informationen beibehalten, Konstanz Informationen erhalten, und nicht mit den rohen Bytes verwirren.