CKTIS / C++
Unaire `+`: van lambda zonder captures naar functiepointer
In `+hardPass` zorgt de unaire `+` ervoor dat een niet-generieke lambda zonder captures impliciet wordt omgezet in een functiepointer. Door het andere argumenttype kan een andere overload worden gekozen.
Versie: ISO C++23; implementation support may vary
Syntax
auto hardPass = [](int score) { return score >= 40; };
auto ptr = +hardPass; // bool (*)(int)
bool (*callback)(int) = hardPass; // The declared type supplies the target.hardPass is een closure-object met een eigen naamloos klassetype. In +hardPass heeft + één operand: het is het unaire plusteken, geen optelling. De ingebouwde unaire + accepteert een functiepointer en geeft de waarde ervan ongewijzigd terug. Hier wordt de operand eerst impliciet omgezet in bool (*)(int).
auto ptr = +hardPass; declareert dus een pointer, terwijl auto copy = hardPass; het closure-object kopieert. Bij bool (*ptr)(int) = hardPass; is + niet nodig, want de declaratie geeft het doeltype aan. In het voorbeeld kiest kind(hardPass) de template, die zonder omzetting naar een pointer past. Bij kind(+hardPass) passen beide overloads even goed en wint de functie die geen template is.
De conversie vereist lege []: [x], [=] en [&] verhinderen haar, ook als een standaardcapture niets vastlegt. Volgens de gecorrigeerde C++23-regel verhindert een expliciete objectparameter (this …) de conversie eveneens; ondersteuning kan per compiler verschillen. Een generieke lambda zoals [](auto x) { return x; } levert met alleen unaire + geen pointer met een concreet type op. Geef in plaats daarvan het doeltype op: int (*id)(int) = [](auto x) { return x; };.
De pointer behoudt de parameter- en retourtypen en ook noexcept als de aanroepoperator geen uitzonderingen kan gooien. Hij wijst naar een functie, niet naar het closure-object, en is dus niet afhankelijk van de levensduur van hardPass. De functie heeft C++-taallinkage; extern "C"-linkage is niet gegarandeerd.
Voorbeelden
#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';
}
Resultaat
closure function pointer true
De eerste twee regels tonen de gekozen overload vóór en na de conversie. De derde toont het resultaat van `ptr(42)`.
Gerelateerde lessen
- C++ · Les 8 · Gemiddeld · Versie: 2