Comment l'opérateur unaire résout-il l'ambiguïté lors de l'appel d'une fonction avec une expression lambda comme argument ?

Résolution de la surcharge ambiguë avec un opérateur unaire pour les fonctions Lambda

Dans l'extrait de code fourni :

void foo(std::function<void()> f) { f(); }
void foo(void (*f)()) { f(); }

int main()
{
    foo([]() {}); // ambiguous
    foo(+[]() {}); // resolves to function pointer overload
}

Le premier l'appel à foo est ambigu et ne parvient pas à se compiler. Cette ambiguïté vient du fait que l'expression lambda peut être implicitement convertie en std::function et void (*f)().

Pour résoudre cette ambiguïté, l'opérateur unaire est utilisé avant le lambda dans le deuxième appel. L'opérateur convertit l'expression lambda en un type de pointeur de fonction, void (*)(), qui correspond exactement à la deuxième surcharge.

Selon le standard C :

• L'opérateur unaire convertit l'argument en son type sous-jacent (arithmétique, énumération ou pointeur).
• Pour les expressions lambda, la fonction de conversion dans le type de fermeture se convertit explicitement en un pointeur de fonction avec le même paramètre et les mêmes types de retour.

Par conséquent, l'expression []() {} donne un pointeur de fonction void (*)(), qui correspond sans ambiguïté à la deuxième surcharge.

Il est important de noter que l'expression lambda peut également être explicitement converti en un type de pointeur de fonction pour éviter toute ambiguïté :

foo((void (*)())([]() {}));

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!