CKTIS / C++
`+` unaire : convertir une lambda sans capture en pointeur de fonction
Dans `+hardPass`, le `+` unaire déclenche la conversion implicite d’une lambda non générique sans capture en pointeur de fonction. Le changement de type de l’argument peut modifier le choix de la surcharge.
Version : ISO C++23; implementation support may vary
Syntaxe
auto hardPass = [](int score) { return score >= 40; };
auto ptr = +hardPass; // bool (*)(int)
bool (*callback)(int) = hardPass; // The declared type supplies the target.hardPass est un objet fermeture doté de son propre type de classe sans nom. Dans +hardPass, + n’a qu’un opérande : c’est le plus unaire, pas une addition. Le + unaire intégré accepte un pointeur de fonction et renvoie sa valeur sans la modifier. Ici, l’opérande est d’abord converti implicitement en bool (*)(int).
Ainsi, auto ptr = +hardPass; déclare un pointeur, tandis que auto copy = hardPass; copie l’objet fermeture. bool (*ptr)(int) = hardPass; n’a pas besoin de +, car la déclaration fournit le type cible. Dans l’exemple, kind(hardPass) choisit le modèle de fonction, qui convient sans conversion en pointeur. Pour kind(+hardPass), les deux surcharges conviennent aussi bien l’une que l’autre : la fonction non modèle l’emporte.
La conversion exige des crochets [] vides : [x], [=] et [&] l’empêchent, même si une capture par défaut ne capture rien. Selon la règle corrigée de C++23, un paramètre d’objet explicite (this …) l’empêche également ; la prise en charge peut varier selon le compilateur. Une lambda générique comme [](auto x) { return x; } ne donne pas de pointeur de type concret avec le seul + unaire. Indiquez plutôt un type cible : int (*id)(int) = [](auto x) { return x; };.
Le pointeur conserve les types des paramètres et du résultat, ainsi que noexcept si l’opérateur d’appel ne peut pas lever d’exception. Il désigne une fonction, pas l’objet fermeture, et ne dépend donc pas de la durée de vie de hardPass. La fonction a une liaison de langage C++ ; la liaison extern "C" n’est pas garantie.
Exemples
#include <iostream>
#include <type_traits>
using Predicate = bool (*)(int);
const char* kind(Predicate) { return "function pointer"; }
template<class F>
const char* kind(F) { return "closure"; }
int main() {
auto hardPass = [](int score) { return score >= 40; };
auto ptr = +hardPass;
static_assert(std::is_class_v<decltype(hardPass)>);
static_assert(std::is_same_v<decltype(ptr), Predicate>);
std::cout << kind(hardPass) << '\n'
<< kind(+hardPass) << '\n'
<< std::boolalpha << ptr(42) << '\n';
}
Résultat
closure function pointer true
Les deux premières lignes montrent la surcharge choisie avant et après la conversion. La troisième affiche le résultat de `ptr(42)`.
Leçons associées
- C++ · Leçon 8 · Intermédiaire · Version : 2