Início / coding / Perguntas / 79213869
Accepted
Qwe Qwe
Asked: 2024-11-22 14:28:42 +0800 CST

std::function variadic como parâmetro

  • 772

O compilador pode compilar runa função sem falhas. Mas eu não sei como chamar essa função.

#include <iostream>
#include <functional>
#include <utility>
#include <string>

template<class... Args>
void run(std::function<void(Args...)>&& f, Args&&... args) {
    f(std::forward<Args>(args)...);
}


void greet(std::string name, int times) {
    for(int i = 0; i < times; ++i) {
        std::cout << "Hello, " << name << "!\n";
    }
}

int main() {
    std::function<void(std::string, int)> func = greet;
    run<std::string, int>(greet, std::string("Bob"), 2);  // Not working
    run(func, std::string("Bob"), 2);  // Not working
    return 0;
}

O código a seguir está ok e funciona perfeitamente. Só não consegui descobrir como a função no código acima poderia ser chamada.

template<class Functor, typename... Args>
void run(Functor&& f, Args&&... args) {
    f(std::forward<Args>(args)...);
}
c++

2 respostas

  1. Best Answer

    A fonte da falha na dedução são dois descuidos comuns:

    Uma referência rvalue de argumento com tipo que não faz parte da lista de argumentos tempate. Argumento faqui NÃO é uma referência de encaminhamento, é uma referência rvalue.

     template<class... Args>
 void run(std::function<void(Args...)>&& f, Args&&... args)

    Se você remover esse &&, esse caso de uso específico será compilado:

    run(func, std::string("Bob"), 2);

    Outro é que o argumento da função tem o tipo dependendo do pacote de argumentos e por isso o outro caso não será compilado, pois o valor da expressão greeté um ponteiro, não std::function. Pode ser

    run(std::function<void(std::string, int)>(greet), std::string("Bob"), 2);

    Se a função greetaceitar parâmetros de referência, isso resultará em dedução inconsistente do pacote de parâmetros, por exemplo:

     void greet(const std::string&  name, int times)

    causaria falha no código por causa da correspondência de referência de rvalue para lvalue, o que exigiria inúmeras soluções alternativas. Pacotes de parâmetros e argumentos que dependem deles exigem correspondência exata.

    Há boas razões pelas quais std::evokeuma versão mais geral do run()que foi projetado foi:

    template< class F, class... Args >
std::invoke_result_t<F, Args...> invoke( F&& f, Args&&... args )

    Isso não é apenas livre de incompatibilidade de tipos, mas também permite evitar o despacho de chamadas em tempo de execução incorporado em std::function. Se isso não for aceitável ou o despacho em tempo de execução for necessário, é melhor usar os padrões clássicos Visitor, Callback ou Command em vez de tentar usar wrappers de ponteiros de função.

    • 2

  2. Um erro comum é tentar usar std::functionem templates. Se isso for usado, então seus parâmetros de template não estão em contexto de dedução. Se você olhar os templates da biblioteca padrão, verá que eles usam Callableo parâmetro template. Use esse parâmetro também.

    #include <functional>
#include <iostream>
#include <string>
#include <utility>

template <class Callable, class... Args>
void run(Callable f, Args&&... args) {
  f(std::forward<Args>(args)...);
}

void greet(std::string name, int times) {
  for (int i = 0; i < times; ++i) {
    std::cout << "Hello, " << name << "!\n";
  }
}

int main() {
  std::function<void(std::string, int)> func = greet;
  run(greet, std::string("Bob"), 2);  // Working
  run(func, std::string("Bob"), 2);   // Working
  return 0;
}

    Hello, Bob!
Hello, Bob!
Hello, Bob!
Hello, Bob!

    https://godbolt.org/z/aMcbre7af

    • 0

relate perguntas