Comment « std :: function » permet-il d'obtenir une appelabilité polyvalente avec une taille cohérente ?

Implémentation de la fonction std :: pour une appelabilité polyvalente

La fonction std :: fournit un moyen d'encapsuler et de stocker tout type d'appelable tout en conservant une taille fixe. Malgré les différentes tailles de son contenu, telles que les expressions lambda, std::function atteint cette cohérence grâce à une technique connue sous le nom d'effacement de type.

Effacement de type pour divers callables

L'effacement de type implique la création d'une interface commune représentée par une classe de base. Dans le cas de std::function, une classe callable_base définit une fonction virtuelle Operator() qui est implémentée par des classes dérivées pour des types appelables spécifiques. Cette approche permet à std::function de stocker un pointeur vers la classe de base, lui permettant d'envelopper n'importe quel appelable.

Comme chaque appelable peut avoir des implémentations différentes, les classes dérivées sont créées dynamiquement avec std::function gérant le allocation au sein du tas.

Comportement de copie et état interne

Lors de la copie d'un std::function, l'entité appelable interne est copiée plutôt que partagée. Ce comportement est évident dans le test suivant :

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)
}

L'incrément après le premier appel à f1 n'affecte pas f2, ce qui indique que f2 possède sa propre copie de l'entité appelable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!