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
Freigeben: 2024-12-02 06:01:10
Original
721 Leute haben es durchsucht

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); }
};
Nach dem Login kopieren

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();
Nach dem Login kopieren

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!

Quelle:php.cn
Erklärung dieser Website
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
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage