Wie std::function implementiert wird: Typlöschung und Heap-Zuweisung
Ein wichtiges Implementierungsdetail von std::function ist seine Fähigkeit um alle aufrufbaren Elemente zu umschließen, einschließlich Lambda-Ausdrücken. Während Lambdas in der Größe variieren, behält std::function eine feste Größe bei. Dies wird durch eine Technik namens Typlöschung erreicht.
Nehmen Sie ein vereinfachtes Beispiel von std::function
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); } };
Hier gilt std::function ein unique_ptr zu einem Basistyp callable_base. Für jeden verwendeten eindeutigen Funktor wird ein abgeleiteter Typ aufrufbar
Kopien von std::function lösen Kopien des internen aufrufbaren Objekts aus, anstatt den Status zu teilen. Dies geht aus einem Test hervor, bei dem der Wert einer veränderlichen erfassten Variablen erhöht wird:
int value = 5; std::function<void()> f1 = [=]() mutable { std::cout << value++ << '\n'; }; std::function<void()> f2 = f1; // Prints 5 f1(); // Prints 5 (copy of mutable state) f2();
Daher umhüllt std::function aufrufbare Elemente unterschiedlicher Größe mithilfe von Typlöschung und Heap-Zuweisung effizient. Heap-Zuweisungen werden verwendet, um dynamische Typen basierend auf dem umschlossenen Callable zu instanziieren und so eine feste Größe für std::function selbst sicherzustellen.
Das obige ist der detaillierte Inhalt vonWie erreicht „std::function' eine feste Größe, obwohl Callables unterschiedlicher Größe eingeschlossen werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!