主页 / coding / 问题 / 77779226
Accepted
MatG
Asked: 2024-01-08 19:07:43 +0800 CST

为什么将operator()作为std::function调用不起作用

  • 772

考虑这个旨在收集字符串序列的小类：

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) );
       }
};

我计划将其用作：

issues_t issues;
do_something(issues);

这有效：

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

但我宁愿把它当作：

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

这可以编译但不起作用：在调试器中push_back()执行但下划线向量未填充（godbolt），所以我在这里缺少什么？

最小可重现示例：

#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 个回答

  1. Best Answer

    do_something接受const&可以绑定到临时对象的 a 。调用时，会构造do_something一个临时对象，并且字符串存储在它包含的临时对象中，而不是原始的 中。std::function"something"issues_tissues_t issues

    您的设计很容易出现此类错误，而使用模板和 lambda 可能更方便：

    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));
    });
}

    更惯用的说法do_something应该是这样的：

    // 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");
}

    这些“改进”（1、2、3）中的任何一项都不是绝对必要的，但更惯用。

    • 3

相关问题