我应该如何使用默认参数定义 std::function 变量

How should I define a std::function variable with default arguments?

本文关键字：std function 变量 定义 参数 何使用 默认 我应该      更新时间：2023-10-16

要将 std：：function 变量设置为具有默认参数的 lambda 函数，我可以使用auto如下所示：

auto foo = [](int x = 10){cout << x << endl;};
foo();

这将打印 10。

但是我希望 foo 变量驻留在结构中。在结构中我不能使用auto.

struct Bar
{
    auto foo = [](int x = 10}(cout << x << endl}; //error: non-static data member declared ‘auto’
};
Bar bar;
bar.foo();

将auto替换为 std：：function

struct Bar
{
    std::function<void(int x = 10)> foo = [](int x = 10}(cout << x << endl}; //error: default arguments are only permitted for function parameters
};
Bar bar;
bar.foo();

或

struct Bar
{
    std::function<void(int)> foo = [](int x = 10}(cout << x << endl};
};
Bar bar;
bar.foo(); //error: no match for call to ‘(std::function<void(int)>) ()’

没有结构并替换 std：：function 的 auto：

std::function<void(int x)> foo = [](int x = 10){cout << x << endl;};
foo(); //error: no match for call to ‘(std::function<void(int)>) ()’

那么我应该如何声明 foo？

std::function中的签名基于您计划如何调用它，而不是基于您如何构造/分配它。 由于您希望以两种不同的方式调用它，因此您需要存储到不同的std::function对象，如下所示：

struct Call
{
    template<typename F>
    explicit Call(F f) : zero_(f), one_(std::move(f)) {}
    void operator()() { zero_(); }
    void operator()(int i) { one_(i); }
    std::function<void()>    zero_;
    std::function<void(int)> one_;
};

或者，您可以自己执行类型擦除（std::function幕后执行的操作）以仅存储一次 lambda，如下所示：

class TECall
{
    struct Concept
    {   
        Concept() = default;
        Concept(Concept const&) = default;
        virtual ~Concept() = default;
        virtual Concept* clone() const = 0;
        virtual void operator()() = 0;
        virtual void operator()(int) = 0;
    };  
    template<typename T>
    struct Model final : Concept
    {   
        explicit Model(T t) : data(std::move(t)) {}
        Model* clone() const override { return new Model(*this); }
        void operator()() override { data(); }
        void operator()(int i) override { data(i); }
        T data;
    };  
    std::unique_ptr<Concept> object;
public:
    template<typename F>
    TECall(F f) : object(new Model<F>(std::move(f))) {}
    TECall(TECall const& that) : object(that.object ? that.object->clone() : nullptr) {}
    TECall(TECall&& that) = default;
    TECall& operator=(TECall that) { object = std::move(that.object); return *this; }
    void operator()() { (*object)(); }
    void operator()(int i) { (*object)(i); }
};

解决此问题的一种方法是将std::function包装在为您实现默认参数的函子对象中：

struct MyFunc
{
    void operator()(int x = 10) { f(x); }
    std::function<void(int x)> f;
};
struct Bar
{
    MyFunc foo = {[](int x){std::cout << x << "n";}};
};
int main() {
    Bar bar;
    bar.foo();
}

在 C++20 中，您将能够执行以下操作：

struct foo {
    decltype([](int a = 10){std::cout << a << 'n';}) my_lambda{};
};
int main() {
    foo f;
    f.my_lambda();
    f.my_lambda(5);
}

住在戈博尔特上

它看起来确实有点奇怪，但它工作得很好。

使这成为可能的是能够在未评估的上下文中使用 lambda，并默认构造无状态 lambda。

不知道这是否会对您有所帮助，但您可以将 lambda 存储在模板化结构中。

template <typename F>
struct Bar {
  F foo;
  Bar (F fun): foo (std::move (fun)) {}
};
auto f = [](int x = 10) {cout << x << endl;};
Bar<decltype (f)> bar (f);
bar.foo();
auto makeFun = [](){return [](int x = 10) {cout << x << endl;};};
Bar<decltype (makeFun())> bar2 (makeFun());
bar2.foo();
相关文章：