Início / coding / Perguntas / 77779226
Accepted
MatG
Asked: 2024-01-08 19:07:43 +0800 CST

Por que invocar operador() como std::function não funciona

  • 772

Considere esta pequena aula destinada a coletar uma sequência de strings:

class issues_t final
{
 private:
    std::vector<std::string> m_issues;

 public:
    constexpr void operator()(std::string&& txt)
       {
        m_issues.push_back( std::move(txt) );
       }
};

Eu pretendo usar isso como:

issues_t issues;
do_something(issues);

Isso funciona:

void do_something(issues_t& notify_issue)
{
    notify_issue("something");
}

Mas prefiro consumir isso como:

using fnotify_t = std::function<void(std::string&&)>;
void do_something(fnotify_t const& notify_issue)
{
    notify_issue("something");
}

Isso compila, mas não funciona: no depurador, o push_back()é executado, mas o vetor sublinhado não é preenchido ( godbolt ), então o que estou perdendo aqui?

exemplo reproduzível mínimo:

#include <string>
#include <vector>
#include <functional>
#include <print>

class issues_t final
{
 private:
    std::vector<std::string> m_issues;

 public:
    constexpr void operator()(std::string&& txt)
       {
        m_issues.push_back( std::move(txt) );
       }

    [[nodiscard]] constexpr auto begin() const noexcept { return m_issues.cbegin(); }
    [[nodiscard]] constexpr auto end() const noexcept { return m_issues.cend(); }
};

using fnotify_t = std::function<void(std::string&&)>;
void do_first(fnotify_t const& notify_issue)
{
    notify_issue("do_first");
}

void do_second(issues_t& notify_issue)
{
    notify_issue("do_second");
}

int main()
{
    issues_t issues;
    issues("main");
    do_first(issues);
    do_second(issues);

    for( const auto& issue : issues )
       {
        std::print("    {}\n", issue);
       }
}
c++

1 respostas

  1. Best Answer

    do_somethingaceita um const&que pode ser vinculado a objetos temporários. Ao chamar do_something, um objeto temporário std::functioné construído e a "something"string é armazenada no temporário issues_tque ele contém, não no original issues_t issues.

    Seu design está sujeito a esses erros, e trabalhar com modelos e lambdas é provavelmente mais conveniente:

    template <typename F>
void do_something(F f) {
    f("something");
}

int main() {
    std::vector<std::string> issues;

    do_something([&issues](std::string&& s) {
        issues.push_back(std::move(s));
    });
}

    Mais idiomaticamente, do_somethingdeve ser semelhante a:

    // 1. constrain F to make sure f(...) actually works
template <std::invocable<const char*> F>
void do_something(F&& f) {
    // 2. use std::invoke to provide support for member functions pointers and
    //    other things where f() doesn't work
    // 3. perfectly forward f
    std::invoke(std::forward<F>(f), "something");
}

    Qualquer uma dessas "melhorias" (1, 2, 3) não é estritamente necessária, mas é mais idiomática.

    • 3

relate perguntas