编程参考 - 如何判断C++的std::funciton是否为空

在 C++ 中，当一个 std::function 对象不包含任何可调用的目标时，该对象就被视为 null 或 empty。默认情况下，当你默认构造一个 std::function 时，它确实是空的。这意味着它不指向任何函数或可调用对象。

In C++, an std::function object is considered null or empty when it doesn't contain any callable target. By default, when you default-construct an std::function, it is indeed empty. This means it doesn't refer to any function or callable object.

#include <iostream>

#include <functional>

int main() {

    std::function<void()> func;

    if (!func) {

        std::cout << "The std::function object is null (empty)." << std::endl;

    } else {

        std::cout << "The std::function object is not null." << std::endl;

    }

    return 0;

}

Output:

The std::function object is null (empty).

在本例中，func 是默认构造的，所以它是空的。if (!func) 条件通过使用 std::function 提供的隐式 bool 转换来检查 func 是否为空，其中空的 std::function 会求值为 false。

In this example, func is default-constructed, so it is empty. The condition if (!func) checks if func is empty by using the implicit conversion to bool provided by std::function, where an empty std::function evaluates to false.

值得注意的是，你可以通过赋值 nullptr 或 empty lambda 表达式来明确指定 std::function 为空。例如:

It's worth noting that you can explicitly specify that an std::function is empty by assigning it nullptr or an empty lambda expression. For example:

std::function<void()> func = nullptr;

// or

std::function<void()> func = [](){};

判断std::function对象是否为空的方法

在 C++ 中，如果一个类提供了显式或隐式转换操作符（如操作符 bool()），则可以在表达式中直接调用该操作符。不过，直接调用转换运算符有时并不直观，因为它们通常是在条件检查（如 if (func)）中隐式调用的。

In C++, if a class provides an explicit or implicit conversion operator, such as operator bool(), you can invoke this operator directly in expressions. However, directly calling conversion operators can sometimes be non-intuitive because they are usually called implicitly in condition checks (e.g., if (func)).

Using the Conversion Operator Implicitly / 隐式使用转换操作符

通常，您会在条件中隐含使用转换运算符：

Normally, you would use the conversion operator implicitly in a condition:

std::function<void()> func;

if (func) {

    // This implicitly calls func.operator bool()

    func();

}

Calling the Conversion Operator Explicitly /  明确调用转换操作符

要显式调用操作符 bool()，可以将其作为成员函数直接调用：

To explicitly call operator bool(), you can do it by directly invoking it as a member function:

#include <iostream>

#include <functional>

int main() {

    std::function<void()> func;

    // Assign a lambda expression to the std::function object

    func = []() { std::cout << "Hello, World!" << std::endl; };

    // Explicitly call the conversion operator

    bool is_callable = static_cast<bool>(func);

    

    // Or use the C-Style syntax

    is_callable = (bool)func;

    if (is_callable) {

        std::cout << "The std::function object is not null." << std::endl;

        func(); // This will print "Hello, World!"

    } else {

        std::cout << "The std::function object is null (empty)." << std::endl;

    }

    return 0;

}

说明

1. 条件表达式中的隐式调用： 表达式 if (func) 隐式调用了 func.operator bool()。这是在条件语句中使用 std::function 或其他带有操作符 bool() 的类型的常见惯用方式。

2. 显式调用：static_cast<bool>(func) 显式调用操作符 bool() 转换操作符。这种情况并不常见，但为了清晰起见，或需要将转换结果存储在变量中时，这种方法会很有用。

在上面的示例中

* std::function对象 func 被分配了一个 lambda 表达式，使其成为非空对象。

* 我们使用 static_cast<bool>(func)显式调用operator bool() 转换操作符，如果 func 包含一个可调用的目标，则返回 true。

* 变量 is_callable 保存了转换的结果，我们用它来决定是否调用 func。

Explanation: 1. Implicit Call in Condition: The expression if (func) implicitly calls func.operator bool(). This is the common and idiomatic way to use std::function or any other type with an operator bool() in conditional statements. 2. Explicit Call: static_cast<bool>(func) explicitly invokes the operator bool() conversion operator. This is less common but can be useful for clarity or when you need to store the result of the conversion in a variable. In the example above: * The std::function object func is assigned a lambda expression, making it non-empty. * We explicitly call the operator bool() conversion operator using static_cast<bool>(func), which returns true if func contains a callable target. * The variable is_callable holds the result of the conversion, and we use it to determine whether to call func.

如果出于某种原因需要调用转换操作符，这种方法提供了一种清晰明确的调用方式。不过，在大多数实际情况下，在条件语句中隐式使用更简单易读。

This approach provides a clear and explicit way to invoke the conversion operator if you need to do so for any reason. However, in most practical scenarios, the implicit usage within conditional statements is preferred for its simplicity and readability.

如果没有定义此类操作符 - operator bool()，在条件表达式中使用对象将导致编译错误，因为编译器不知道如何将对象隐式转换为 bool。

If no such operator is defined, using the object in a condition expression will result in a compilation error, as the compiler won't know how to implicitly convert the object to a bool.