L'argument de modèle de std::function est-il inclus dans son type ?

Introduction au problème

Lors de l'utilisation du modèle std::function, ambiguïté peut survenir en raison de plusieurs surcharges plausibles. Plus précisément, considérez l'extrait de code suivant :

#include 

using namespace std;

int a(const function& f) { return f(); }
int a(const function& f) { return f(0); }
int x() { return 22; }
int y(int) { return 44; }

int main() {
    a(x); // Call is ambiguous.
    a(y); // Call is ambiguous.
}

L'ambiguïté vient du fait que function et function peuvent être construites à partir d'un pointeur de fonction générique. Cela introduit plusieurs correspondances potentielles pour les surcharges de la fonction a.

Résolution d'ambiguïté

La signature de l'argument de modèle pour std::function est considérée comme faisant partie de son type lors de la déclaration et de la définition. Cependant, ce n'est pas le cas lors de la construction d'un objet.

std::function, comme de nombreux objets fonctionnels en C , utilise une technique appelée effacement de type. Cela lui permet d'accepter des objets ou des fonctions arbitraires, à condition qu'ils satisfassent à la signature attendue lors de leur appel. L'inconvénient est que les erreurs liées aux signatures incompatibles se produisent au plus profond de l'implémentation, plutôt qu'au niveau du constructeur.

Contourner l'ambiguïté

Trois options principales existent pour contourner cette ambiguïté :

• Casting de type explicite : convertissez manuellement les pointeurs de fonction vers la signature spécifique requise par le destinataire prévu. surcharge.
• Function Object Wrapping : Créez un objet fonction du type approprié et transmettez-le à la place.
• Template Metaprogramming (TMP) : Utiliser TMP pour générer une fonction avec la signature souhaitée, en évitant les conversions explicites.

Conclusion

Alors que l'argument de modèle de std::function détermine son type lors des déclarations et des définitions, il ne joue aucun rôle dans la construction d'objets. Cela peut conduire à une ambiguïté lorsque les constructeurs acceptent des arguments arbitraires. Pour résoudre ce problème, les programmeurs peuvent utiliser la conversion de type explicite, l'encapsulation d'objet de fonction ou TMP.