Setter of a lambda function?

Setter of a lambda function?

本文关键字：function lambda of Setter      更新时间：2023-10-16

考虑以下愚蠢的例子:

class MyClass
{
    public:
        template <class Function> 
        inline double f(double x, Function&& function)
        {
            return function(x);
        }
};

有了这个类，我可以调用MyClass::f(x, function)，用lambda函数在x上执行它，(我希望)没有开销。我的问题是:function作为MyClass的可设置成员的等效是什么?

class MyClass
{
    public:
        inline double f(double x)
        {
            return _function(x);
        }
    // What are the setter and the type of the protected member _function ?
};

Lambda函数(以及一些其他类型的"可调用"函数)可以使用std::function模板类包装和存储，在<functional>头文件中找到。它的模板形参是一个函数签名，语法为

ReturnType(ArgumentType1, ArgumentType2, ...)

所以在你的例子中，整个函数包装器类型变成

std::function<double(double)>

，因此，你的代码变成

class MyClass
{
    public:
        inline double f(double x)
        {
            return _function(x);
        }
        void setFunction(std::function<double(double)> && f)
        {
            _function = f;
        }
    private:
        std::function<double(double)> _function;
};

std::function"不仅仅"是函数指针的包装器。您可能知道，lambda函数可以捕获变量上下文的一部分，这些上下文需要存储在某个地方。std::function为您透明地完成此操作。

注意std::function不支持函数的重载签名/模板化调用操作符。当将具有调用操作符签名(如T operator()(T value))的函子赋值给std::function<double(double)>时，只能使用此签名调用该函子。所以没有std::function<T(T)>(除非T是已知的，比如你的类的模板参数)。

在某些情况下(您需要对其进行基准测试/配置文件)，另一种可能更有效的方法是使整个类成为模板类，并将函数类型参数作为模板参数。然后可以将函数存储为成员:

template<typename Function>
class MyClass
{
    public:
        MyClass(Function && f) :
            _function(f)
        {}
        inline double f(double x)
        {
            return _function(x);
        }
    private:
        Function _function;
};

为了创建这样一个对象，需要指定模板参数，如下所示:

auto myLambda = [](double x){ return x * 0.25; };
MyClass<decltype(myLambda)> myObject { myLambda };

为了避免这种难看的语法开销，添加一个利用模板类型推导的"maker"函数:

template<typename Function>
auto makeMyClass(Function && f) -> MyClass<Function> {
    return MyClass<Function>(f);
}

然后，再次使用auto，代码变得更可读:

auto myLambda = [](double x){ return x * 0.25; };
auto myObject = makeMyClass(myLambda);

您必须使用std::function包装器，可能让构造函数从输入可调用对象初始化它:

#include <functional> // <== REQUIRED FOR std::function
class MyClass
{
    public:
        template<typename F>
        MyClass(F&& f) : _function(std::forward<F>(f)) { }
        inline double f(double x)
        {
            return _function(x);
        }
    private:
        std::function<double(double)> _function;    
};

注意，这可能会给您带来一些运行时开销，但是设计是简单而灵活的。除非您能够证明此运行时开销是软件性能需求的瓶颈，否则不应该关注此运行时开销。

相关文章：