Unterschied zwischen std :: reference_wrapper und einfachem Zeiger?

Warum muss es sein std::reference_wrapper? Wo soll es verwendet werden? Wie unterscheidet es sich von einem einfachen Zeiger? Wie ist seine Leistung im Vergleich zu einem einfachen Zeiger?

std::reference_wrapperist nützlich in Kombination mit Vorlagen. Es umschließt ein Objekt, indem es einen Zeiger darauf speichert, wodurch eine Neuzuweisung und ein Kopieren ermöglicht werden, während die übliche Semantik nachgeahmt wird. Außerdem werden bestimmte Bibliotheksvorlagen angewiesen, Referenzen anstelle von Objekten zu speichern.

Betrachten Sie die Algorithmen in der STL, die Funktoren kopieren: Sie können diese Kopie vermeiden, indem Sie einfach einen Referenz-Wrapper übergeben, der sich auf den Funktor anstelle des Funktors selbst bezieht:

unsigned arr[10];
std::mt19937 myEngine;
std::generate_n( arr, 10, std::ref(myEngine) ); // Modifies myEngine's state

Das funktioniert, weil…

• … reference_wrapperS Überlastung,operator() so dass sie genau wie die Funktionsobjekte aufgerufen werden können, auf die sie sich beziehen:

  std::ref(myEngine)() // Valid expression, modifies myEngines state

• … (Un) wie bei normalen Referenzen wird beim Kopieren (und Zuweisen) reference_wrappersnur der Pointee zugewiesen.

  int i, j;
  auto r = std::ref(i); // r refers to i
  r = std::ref(j); // Okay; r refers to j
  r = std::cref(j); // Error: Cannot bind reference_wrapper<int> to <const int>

Das Kopieren eines Referenz-Wrappers entspricht praktisch dem Kopieren eines Zeigers, der so billig wie möglich ist. Alle Funktionsaufrufe, die mit der Verwendung verbunden sind (z. B. die zu operator()), sollten nur als Inline-Aufrufe eingefügt werden.

reference_wrappers werden erstellt über std::refundstd::cref :

int i;
auto r = std::ref(i); // r is of type std::reference_wrapper<int>
auto r2 = std::cref(i); // r is of type std::reference_wrapper<const int>

Das Template-Argument gibt den Typ und die Lebenslaufqualifikation des Objekts an, auf das verwiesen wird. r2bezieht sich auf a const intund gibt nur einen Verweis auf const int. Aufrufe von Referenz-Wrappern mit constFunktoren rufen nur constMitgliedsfunktionen auf operator().

R-Wert-Initialisierer sind nicht zulässig, da ihre Zulassung mehr schaden als nützen würde. Da r-Werte ohnehin verschoben würden (und bei garantierter Kopierentfernung auch dies teilweise vermieden wird), verbessern wir die Semantik nicht. Wir können jedoch baumelnde Zeiger einführen, da ein Referenz-Wrapper die Lebensdauer des Pointees nicht verlängert.

Bibliotheksinteraktion

Wie bereits erwähnt, kann man anweisen make_tuple, eine Referenz im Ergebnis zu speichern, tupleindem man das entsprechende Argument durch a reference_wrapper:

int i;
auto t1 = std::make_tuple(i); // Copies i. Type of t1 is tuple<int>
auto t2 = std::make_tuple(std::ref(i)); // Saves a reference to i.
                                        // Type of t2 is tuple<int&>

Beachten Sie, dass sich dies geringfügig unterscheidet von forward_as_tuple: Hier sind rWerte als Argumente nicht zulässig.

std::bindzeigt das gleiche Verhalten: Es wird das Argument nicht kopiert, sondern eine Referenz gespeichert, wenn es eine ist reference_wrapper. Nützlich, wenn dieses Argument (oder der Funktor!) Nicht kopiert werden muss, sondern im Gültigkeitsbereich bleibt, während der bindFunktor verwendet wird.

Unterschied zu gewöhnlichen Zeigern

• Es gibt keine zusätzliche Ebene der syntaktischen Indirektion. Zeiger müssen dereferenziert werden, um einen Wert für das Objekt zu erhalten, auf das sie sich beziehen. reference_wrappers haben einen impliziten Konvertierungsoperator und können wie das Objekt aufgerufen werden, das sie umschließen.

  int i;
  int& ref = std::ref(i); // Okay

• reference_wrappers haben im Gegensatz zu Zeigern keinen Nullstatus. Sie müssen entweder mit einer Referenz oder einer anderenreference_wrapper initialisiert werden .

  std::reference_wrapper<int> r; // Invalid

• Eine Ähnlichkeit ist die flache Kopiersemantik: Zeiger und reference_wrappers können neu zugewiesen werden.

Es gibt mindestens zwei motivierende Zwecke std::reference_wrapper<T>:

1. Es dient dazu, Objekten, die als Wertparameter an Funktionsvorlagen übergeben werden, eine Referenzsemantik zu geben. Beispielsweise möchten Sie möglicherweise ein großes Funktionsobjekt übergeben, an std::for_each()das der Funktionsobjektparameter als Wert übergeben wird. Um das Kopieren des Objekts zu vermeiden, können Sie verwenden

   std::for_each(begin, end, std::ref(fun));

   Das Übergeben von Argumenten std::reference_wrapper<T>für einen std::bind()Ausdruck ist weit verbreitet, um Argumente eher nach Referenz als nach Wert zu binden.

2. Bei Verwendung eines std::reference_wrapper<T>mit std::make_tuple()dem entsprechenden Tupelelement wird T&eher ein als ein T:

   T object;
   f(std::make_tuple(1, std::ref(object)));

Ein weiterer Unterschied in Bezug auf reference_wrapperselbstdokumentierenden Code besteht darin, dass die Verwendung eines Codes das Eigentum an dem Objekt im Wesentlichen ablehnt. Im Gegensatz dazu unique_ptrbehauptet ein Ass den Besitz, während ein bloßer Zeiger möglicherweise im Besitz ist oder nicht (es ist nicht möglich zu wissen, ohne viele verwandte Codes zu betrachten):

vector<int*> a;                    // the int values might or might not be owned
vector<unique_ptr<int>> b;         // the int values are definitely owned
vector<reference_wrapper<int>> c;  // the int values are definitely not owned

Sie können es sich als praktischen Wrapper für Referenzen vorstellen, damit Sie sie in Containern verwenden können.

std::vector<std::reference_wrapper<T>> vec; // OK - does what you want
std::vector<T&> vec2; // Nope! Will not compile

Es ist im Grunde eine CopyAssignableVersion von T&. Jedes Mal, wenn Sie eine Referenz wünschen, diese aber zuweisbar sein, verwenden std::reference_wrapper<T>oder ihre Hilfsfunktion haben muss std::ref(). Oder verwenden Sie einen Zeiger.

Andere Macken: sizeof:

sizeof(std::reference_wrapper<T>) == sizeof(T*) // so 8 on a 64-bit box
sizeof(T&) == sizeof(T) // so, e.g., sizeof(vector<int>&) == 24

Und Vergleich:

int i = 42;
assert(std::ref(i) == std::ref(i)); // ok

std::string s = "hello";
assert(std::ref(s) == std::ref(s)); // compile error