Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

`+` unario: da lambda senza catture a puntatore a funzione

In `+hardPass`, il `+` unario induce la conversione implicita di una lambda non generica senza catture in un puntatore a funzione. Il cambio di tipo dell’argomento può modificare la scelta del sovraccarico.

Versione: ISO C++23; implementation support may vary

Sintassi

auto hardPass = [](int score) { return score >= 40; };
auto ptr = +hardPass; // bool (*)(int)
bool (*callback)(int) = hardPass; // The declared type supplies the target.

hardPass è un oggetto di chiusura con un proprio tipo di classe senza nome. In +hardPass, + ha un solo operando: è il più unario, non un’addizione. Il + unario predefinito accetta un puntatore a funzione e ne restituisce il valore invariato. Qui l’operando viene prima convertito implicitamente in bool (*)(int).

Quindi auto ptr = +hardPass; dichiara un puntatore, mentre auto copy = hardPass; copia l’oggetto di chiusura. bool (*ptr)(int) = hardPass; non richiede + perché la dichiarazione specifica il tipo di destinazione. Nell’esempio, kind(hardPass) seleziona il template, che corrisponde senza conversione a puntatore. Per kind(+hardPass) i due sovraccarichi corrispondono altrettanto bene, quindi prevale la funzione non template.

La conversione richiede [] vuoto: [x], [=] e [&] la impediscono, anche se una cattura predefinita non cattura nulla. Secondo la regola corretta di C++23, anche un parametro oggetto esplicito (this …) la impedisce; il supporto può variare a seconda del compilatore. Una lambda generica come [](auto x) { return x; } non produce un puntatore di tipo concreto con il solo + unario. Specifica invece il tipo di destinazione: int (*id)(int) = [](auto x) { return x; };.

Il puntatore conserva i tipi dei parametri e del valore restituito, oltre a noexcept se l’operatore di chiamata non può lanciare eccezioni. Punta a una funzione, non all’oggetto di chiusura, quindi non dipende dalla durata di vita di hardPass. La funzione ha linkage di linguaggio C++; il linkage extern "C" non è garantito.

Esempi

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

Risultato

closure
function pointer
true

Le prime due righe mostrano la scelta del sovraccarico prima e dopo la conversione. La terza mostra il risultato di `ptr(42)`.

Lezioni correlate

  • C++ · Lezione 8 · Intermedio · Versione: 2

Fonti