WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Unäres `+`: vom Lambda ohne Captures zum Funktionszeiger

Bei `+hardPass` bewirkt das unäre `+` die implizite Konvertierung eines nichtgenerischen Lambdas ohne Captures in einen Funktionszeiger. Der neue Argumenttyp kann die Überladungsauswahl ändern.

Version: 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 ist ein Closure-Objekt mit einem eigenen unbenannten Klassentyp. In +hardPass hat + nur einen Operanden: Es ist das unäre Plus, keine Addition. Das eingebaute unäre + akzeptiert einen Funktionszeiger und gibt seinen Wert unverändert zurück. Hier wird der Operand zuerst implizit in bool (*)(int) konvertiert.

auto ptr = +hardPass; deklariert daher einen Zeiger, während auto copy = hardPass; das Closure-Objekt kopiert. bool (*ptr)(int) = hardPass; braucht kein +, da die Deklaration den Zieltyp vorgibt. Im Beispiel wählt kind(hardPass) das Template, das ohne Zeigerkonvertierung passt. Bei kind(+hardPass) passen beide Überladungen gleich gut, sodass die Nicht-Template-Funktion gewinnt.

Die Konvertierung setzt leere [] voraus: [x], [=] und [&] verhindern sie, selbst wenn ein Standard-Capture nichts erfasst. Nach der korrigierten C++23-Regel schließt auch ein expliziter Objektparameter (this …) die Konvertierung aus; die Compilerunterstützung kann variieren. Ein generisches Lambda wie [](auto x) { return x; } ergibt mit unärem + allein keinen konkreten Zeiger. Gib stattdessen einen Zieltyp vor: int (*id)(int) = [](auto x) { return x; };.

Der Zeiger behält die Parameter- und Rückgabetypen sowie noexcept bei, wenn der Aufrufoperator keine Ausnahmen werfen kann. Er zeigt auf eine Funktion, nicht auf das Closure-Objekt, und hängt daher nicht von der Lebensdauer von hardPass ab. Die Funktion hat C++-Sprachbindung, keine garantierte extern "C"-Sprachbindung.

Beispiele

#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';
}

Ergebnis

closure
function pointer
true

Die ersten beiden Zeilen zeigen die Überladungsauswahl vor und nach der Konvertierung. Die dritte zeigt das Ergebnis von `ptr(42)`.

Zugehörige Lektionen

  • C++ · Lektion 8 · Mittlere Stufe · Version: 2

Quellen