如何实现Lambda直接转换为Predicate类对象并简化Lambda写法？

现有实现代码 #

Predicate类定义 #

namespace _utils{

    namespace _functional{

        template <typename T>
        class Predicate: public FunctionalI{
            protected:
                std::function<bool(T)> predicate;

            public:
                Predicate(std::function<bool(T)> predicate){
                    this->predicate = predicate;
                }

                inline bool test(T t){
                    return this->predicate(t);
                }
        };
    }
}

原始测试代码 #

bool foo(_functional::Predicate<int> predicate){
    return predicate.test(2);
}

int main(){
    _functional::Predicate<int> tmp = _functional::Predicate<int>([] (int x) ->  bool{ return x == 2; });

    std::cout << foo(tmp);

    return 0;
}

待解决的问题 #

1. 能否简化Lambda的使用方式，无需显式调用Predicate构造函数，直接把Lambda传入接受Predicate类型参数的函数？期望写法：

bool foo(_functional::Predicate<int> predicate){
    return predicate.test(2);
}

int main(){
    foo([] (int x) -> bool{return x == 2;} );

    return 0;
}

2. 能否简化Lambda表达式本身，省略返回类型和return关键字？

解决方案 #

问题1：支持直接传入Lambda到接受Predicate的函数 #

要实现这个需求，只需要给Predicate类新增一个模板构造函数，让它能直接接收任意可调用对象（包括Lambda），而不是仅局限于std::function<bool(T)>。修改后的Predicate类代码如下：

namespace _utils{

    namespace _functional{

        template <typename T>
        class Predicate: public FunctionalI{
            protected:
                std::function<bool(T)> predicate;

            public:
                // 保留原构造函数，兼容std::function类型
                Predicate(std::function<bool(T)> predicate) : predicate(std::move(predicate)) {}

                // 新增模板构造函数，接受任意可调用对象
                template <typename Callable>
                Predicate(Callable&& callable) : predicate(std::forward<Callable>(callable)) {}

                inline bool test(T t){
                    return predicate(t);
                }
        };
    }
}

修改后，编译器会自动将Lambda隐式转换为Predicate<int>类型，你就可以直接用foo([] (int x) -> bool{return x == 2;} );这种简化写法了。

另外建议把函数参数改成const引用传递，避免不必要的对象拷贝：

bool foo(const _functional::Predicate<int>& predicate){
    return predicate.test(2);
}

问题2：简化Lambda表达式本身 #

C++11及以后标准支持Lambda的返回类型自动推导，且当Lambda体只有单个表达式时，可以省略大括号、return关键字和返回类型。你的Lambda可以简化为以下两种形式：

1. 仅省略返回类型：

foo([] (int x) { return x == 2; } );

编译器会自动推导返回类型为bool。

2. 极致简化（省略大括号、return和返回类型）：

foo([] (int x) x == 2 );

这是单表达式Lambda的标准简化写法，编译器会自动处理类型推导和返回逻辑。

内容的提问来源于stack exchange，提问作者DynoZ