Wie behält std::function eine feste Größe bei, obwohl Lambda-Ausdrücke variabler Größe verarbeitet werden?

Untersuchung der Implementierung von std::function

In der Welt der Lambda-Ausdrücke wird die Vorstellung von Größe so fließend, wie sie ist im Wesentlichen in Klassen mit Referenzen variabler Größe verpackt. Allerdings erfordert std::function eine feste Größe. Da stellt sich die Frage: Wie lässt sich das vereinbaren?

Die Antwort liegt in der Löschung des Typs. Stellen wir uns eine vereinfachte Implementierung vor:

struct callable_base {
   virtual int operator()(double d) = 0;
   virtual ~callable_base() {}
};
template <typename F>
struct callable : callable_base {
   F functor;
   callable(F functor) : functor(functor) {}
   virtual int operator()(double d) { return functor(d); }
};
class function_int_double {
   std::unique_ptr<callable_base> c;
public:
   template <typename F>
   function(F f) {
      c.reset(new callable<F>(f));
   }
   int operator()(double d) { return c(d); }
};

In diesem vereinfachten Ansatz speichert std::function einen eindeutigen Zeiger auf eine Basisklasse. Für jeden einzelnen Funktor wird ein abgeleiteter Typ erstellt und dynamisch instanziiert. Somit bleibt die Größe von std::function konstant, während eine Reihe von Funktoren auf dem Heap untergebracht werden.

Optimierungstechniken verfeinern dieses Schema weiter, indem sie kleine Objektoptimierungen verwenden, Indirektionen vermeiden und dergleichen. Konzeptionell bleibt die Kernidee jedoch dieselbe.

Bezüglich Kopien von std::function deuten experimentelle Erkenntnisse auf unabhängige Kopien des aufrufbaren Objekts hin. Ein erfundenes Beispiel:

int main() {
   int value = 5;
   typedef std::function<void()> fun;
   fun f1 = [=]() mutable { std::cout << value++ << '\n' };
   fun f2 = f1;
   f1(); // prints 5
   fun f3 = f1;
   f2(); // prints 5
   f3(); // prints 6 (copy after first increment)
}

Die Ausgabe zeigt isolierte Kopien und keinen gemeinsamen Status an, da die verschiedenen Aufrufe den Wert unabhängig voneinander erhöhen.

Das obige ist der detaillierte Inhalt vonWie behält std::function eine feste Größe bei, obwohl Lambda-Ausdrücke variabler Größe verarbeitet werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!