如何在C++中使用空 Lambda?

How Can I use Null Lambda in C++?

本文关键字：Lambda C++      更新时间：2023-10-16

我想声明一个这样的函数：

template <typename Lambda>
int foo(Lambda bar) {
if(/* check bar is null lambda */)
return -1;
else
return bar(3);
}
int main() {
std::cout << foo([](int a)->int{return a + 3;}) << std::endl;
std::cout << foo(NULL_LAMBDA) << std::endl;
}

那么，如何声明NULL_LAMBDA和条件检查传递的lambda函数是否为空？

您可以添加专门的专业化：

#include <iostream>
#include <cstddef>
template<typename Lambda> int
foo(Lambda bar)
{
return(bar(3));
}
template<> int
foo<::std::nullptr_t>(::std::nullptr_t)
{
return(-1);
}
int main()
{
::std::cout << foo([] (int a) -> int {return(a + 3);}) << ::std::endl;
::std::cout << foo(nullptr) << ::std::endl;
}

在这种特殊情况下，您可以将 null 闭包定义为始终返回-1的闭包

：
template <typename Lambda>
int foo(Lambda bar) {
return bar(3);
}
#include <iostream>
int main() {
auto const NULL_LAMBDA = [](int){ return -1; };
std::cout << foo([](int a) {return a + 3;}) << std::endl;
std::cout << foo(NULL_LAMBDA) << std::endl;
}

可能性是，如果您在运行时选择要传递的实现，那么最好使用std::function而不是实例化模板来擦除它。 并且允许std::function为空- 它可以从空指针分配并与空指针进行比较。

如果您在编译时知道某些调用站点将始终传递"null"lambda，那么您可以适当地专门化实现。 显而易见的选项包括使用不接受bar参数的版本重载foo()，或者在bar不是可调用对象时将其专用于不同的实现。

如果foo()的大部分内容对于这两种调用都是通用的(也许它有很多副作用，并且bar()作为回调提供？(，那么您可以使用std::is_same<>对可选部分进行条件化。 这需要if constexpr，因为 lambda 不可调用为bar(3)：

static auto const NULL_LAMBDA = nullptr;
#include <type_traits>
template <typename Lambda>
int foo(Lambda bar) {
if constexpr (std::is_same<decltype(bar), std::nullptr_t>::value)
return -1;
else
return bar(3);
}
#include <iostream>
int main() {
std::cout << foo([](int a) {return a + 3;}) << std::endl;
std::cout << foo(NULL_LAMBDA) << std::endl;
}

Lambda 是一类类型，而不是一种类型。

我们可以这样做：

struct null_callable_t{
template<class...Ts>
constexpr void operator()(Ts&&...)const{}
explicit constexpr operator bool()const{return false;}
constexpr null_callable_t() {}
friend constexpr bool operator==(::std::nullptr_t, null_callable_t ){ return true; }
friend constexpr bool operator==(null_callable_t, ::std::nullptr_t ){ return true; }
friend constexpr bool operator!=(::std::nullptr_t, null_callable_t ){ return false; }
friend constexpr bool operator!=(null_callable_t, ::std::nullptr_t ){ return false; }
};
constexpr null_callable_t null_callable{};

现在我们的代码变成：

template <typename Lambda>
int foo(Lambda bar) {
if(!bar)
return -1;
else
return bar(3);
}

这很流畅：

std::cout << foo([](int a) {return a + 3;}) << std::endl;
std::cout << foo(null_callable) << std::endl;

但是，我个人最喜欢的解决这个问题的方法是写function_view。

它将指针和操作包装在一个有点像 std 函数的非分配事物中。 编译器非常擅长内联简单的函数指针，因此如果使方法内联，开销仍然很低。

请注意，在 C++17 中，我们可以这样写...

template<typename Lambda>
int foo(Lambda bar)
{
if constexpr (std::is_same_v<std::decay_t<Lambda>, std::nullptr_t>)
return -1;
else if constexpr (std::is_convertable_v<Lambda, bool>)
{
if (bar)
return bar(3);
else
return -1;
}
else
return bar(3);
}

我想在 C++20 中，我们可以定义一个概念，即 std：：invocable(概念标头(或nulltpr_t来约束 Lambda。

相关文章：