Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes