CKTIS / C++
`+` unário: converter uma lambda sem capturas num ponteiro para função
Em `+hardPass`, o `+` unário provoca a conversão implícita de uma lambda não genérica sem capturas num ponteiro para função. A mudança do tipo do argumento pode alterar a escolha da sobrecarga.
Versão: ISO C++23; implementation support may vary
Sintaxe
auto hardPass = [](int score) { return score >= 40; };
auto ptr = +hardPass; // bool (*)(int)
bool (*callback)(int) = hardPass; // The declared type supplies the target.hardPass é um objeto de fecho com o seu próprio tipo de classe sem nome. Em +hardPass, + tem apenas um operando: é o mais unário, não uma adição. O + unário incorporado aceita um ponteiro para função e devolve o seu valor sem o alterar. Neste caso, o operando é primeiro convertido implicitamente em bool (*)(int).
Assim, auto ptr = +hardPass; declara um ponteiro, enquanto auto copy = hardPass; copia o objeto de fecho. bool (*ptr)(int) = hardPass; não precisa de + porque a declaração indica o tipo de destino. No exemplo, kind(hardPass) seleciona o modelo de função, que é compatível sem conversão para ponteiro. Em kind(+hardPass), ambas as sobrecargas são igualmente adequadas e vence a função que não é um modelo.
A conversão exige [] vazio: [x], [=] e [&] impedem-na, mesmo quando uma captura por omissão não captura nada. Segundo a regra corrigida de C++23, um parâmetro de objeto explícito (this …) também a impede; o suporte pode variar consoante o compilador. Uma lambda genérica como [](auto x) { return x; } não produz um ponteiro de tipo concreto apenas com o + unário. Indica antes o tipo de destino: int (*id)(int) = [](auto x) { return x; };.
O ponteiro conserva os tipos dos parâmetros e do valor devolvido, bem como noexcept se o operador de chamada não puder lançar exceções. Aponta para uma função, não para o objeto de fecho, pelo que não depende do tempo de vida de hardPass. A função tem ligação de linguagem C++; a ligação extern "C" não é garantida.
Exemplos
#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';
}
Resultado
closure function pointer true
As duas primeiras linhas mostram a escolha da sobrecarga antes e depois da conversão. A terceira mostra o resultado de `ptr(42)`.
Lições relacionadas
- C++ · Lição 8 · Intermédio · Versão: 2