Início / coding / Perguntas / 79593162
Accepted
463035818_is_not_an_ai
Asked: 2025-04-26 02:58:18 +0800 CST

Como a conversão para o tipo de ponteiro de função é especial, pois permite a conversão implícita de um chamável?

  • 772

Esta é uma continuação desta pergunta: Por que posso chamar um callable que é referenciado por constante e onde o callable real é um lambda mutável?

Posso imitar a conversão implícita de um fechamento mutável const para um ponteiro de função quando ele é chamado assim:

#include <iostream>

void dummy() { std::cout << "call dummy\n";}

using fptr = void(*)();

struct callable {
    void operator()() {std::cout << "call callable\n"; }
    operator fptr() const { 
        std::cout << "convert\n";
        return &dummy; 
    }
};

int main()
{
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn(); 
    }; 
    exec( callable{} );
}

Demonstração ao vivo

Não entendo por que a conversão implícita é acionada. Ela não ocorre ao passar o argumento (o argumento é deduzido, portanto, não leva em consideração a conversão implícita), mas apenas quando ()é invocada, como evidenciado pela saída:

call
convert
call dummy

Tentei experimentar para entender o que estava acontecendo. Tentar algo semelhante com um operador diferente não funcionou (como esperado):

#include <iostream>

struct bar {
    void operator+(int) const { std::cout << "bar\n"; };   
};

struct foo {
    void operator+(int) { std::cout << "foo\n"; }
    operator bar() const { return  {}; }
};

int main() {
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn + 42; 
    }; 
    exec(foo{});
};

erro :

<source>:15:12: error: passing 'const foo' as 'this' argument discards qualifiers [-fpermissive]
   15 |         fn + 42;
      |         ~~~^~~~

O que há de especial no operador de chamada? Como é possível que ele fn()converta implicitamente fnpara chamar outra coisa?

PS: Enquanto isso, descobri que deve estar relacionado à conversão para ponteiro de função, porque quando transformo o primeiro exemplo em algo mais parecido que o segundo, recebo o erro esperado:

#include <iostream>

struct foo {
    void operator()() const { std::cout << "call foo\n"; }

};

struct callable {
    void operator()() {std::cout << "call callable\n"; }
    operator foo() const { return {}; };
};

int main()
{
    auto exec = []( auto const &fn ) { 
        std::cout << "call\n";
        fn(); 
    }; 
    exec( callable{} );
}

Agora recebo o erro esperado

<source>:17:11: error: no match for call to '(const callable) ()'
   17 |         fn();
      |         ~~^~

Agora a questão é: O que há de especial nas conversões para o tipo de ponteiro de função?

Parece que fn()leva em conta conversões para ponteiros de função. Por quê?

c++

2 respostas

  1. Best Answer

    Este comportamento especial para conversão em tipos de função é definido em [over.call.object] :

    Se a expressão pós-fixada E na sintaxe de chamada de função for avaliada como um objeto de classe do tipo " cvT ", então o conjunto de funções candidatas inclui pelo menos os operadores de chamada de função de T. Os operadores de chamada de função de Tsão os resultados de uma busca pelo nome operator()no escopo de T.

    Além disso, para cada função de conversão não explícita declarada no Tformato

    operator conversion-type-id ( ) cv-qualifier-seq ref-qualifier noexcept-specifier attribute-specifier-seq ;

    onde o cv-qualifier-seq opcional é a mesma qualificação cv que, ou uma qualificação cv maior que, cv , e onde conversion-type-id denota o tipo “ponteiro para função de (P 1 ,…,P n ) retornando R”, ou o tipo “referência para ponteiro para função de (P 1 ,…,P n ) retornando R”, ou o tipo “referência para função de (P 1 ,…,P n ) retornando R”, uma função de chamada substituta com o nome exclusivo call-function e tendo o formato

    R call-function ( conversion-type-id  F, P1 a1, …, Pn an) { return F (a1, …, an); }

    também é considerada uma função candidata. Da mesma forma, funções de chamada substituta são adicionadas ao conjunto de funções candidatas para cada função de conversão não explícita declarada em uma classe base, Tdesde que a função não esteja oculta Tpor outra declaração interveniente.

    A lista de argumentos enviada para resolução de sobrecarga consiste nas expressões de argumento presentes na sintaxe de chamada de função precedidas pelo argumento de objeto implícito (E).

    No seu exemplo, a expressão pós-fixada E é fn, que é avaliada como um objeto de classe do tipo const callable. Como callablehá um operador de conversão para "ponteiro para a função de ()retorno void" e esse operador é constqualificado como -, a função substituta void unique_name(fptr F) { return F(); }é imaginada e a chamada unique_name((fn))é considerada para a expressão fn().

    • 7

  2. Para realmente tornar o +caso equivalente, seria algo assim :

    struct bar {};
void operator+(bar const&, int) { std::cout << "bar\n"; };

    E então ele compila e gera:

    call
bar

    A diferença é que membro bar::operator+(int)não é um candidato, enquanto não membro ::operator+(bar const&, int)é (já que está no escopo; não será encontrado via ADL se você envolvê-lo em um namespace - tipos de retorno de operador de conversão não contribuem para o ADL dessa forma).

    Na verdade, inteiros possuem operadores não-membros incorporados definidos, conforme descrito em [over.built/10] . O comportamento da expressão de chamada é definido separadamente em [over.call.object], mas é essencialmente o mesmo como se não-membro ::operator()(F*)fosse uma coisa e definido para cada tipo de função F.

    • 5

relate perguntas