Heim >Backend-Entwicklung >C++ >Wie erreicht „std::function' eine feste Größe, obwohl Callables unterschiedlicher Größe eingeschlossen werden?

Wie erreicht „std::function' eine feste Größe, obwohl Callables unterschiedlicher Größe eingeschlossen werden?

DDD
DDDOriginal
2024-12-02 06:01:10798Durchsuche

How Does `std::function` Achieve Fixed Size Despite Wrapping Callables of Varying Sizes?

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 wird dynamisch auf dem Heap erstellt und instanziiert. Dadurch wird sichergestellt, dass das std::function-Objekt eine konstante Größe behält und gleichzeitig jedes aufrufbare Objekt umschließen kann.

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!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn