首页 > 编程笔记 > C++笔记 阅读：3

C++ std::bind()函数模板的用法（非常详细，附带实例）

在 C++ 中，可调用对象是任何可以使用函数调用操作符（()）执行的实体，包括函数指针、类的成员函数以及 Lambda 表达式。

std::bind() 是 C++ 中的一个函数模板，允许创建一个新的可调用对象，这个对象将一个可调用实体（如函数、成员函数、函数对象等）和其部分或全部参数绑定在一起。这使得我们可以在调用时只需提供剩余的参数，从而增加代码的灵活性和可复用性。

C++ std::bind()的定义

std::bind() 定义在头文件 <functional> 中，并提供了两种形式的模板。

第一种是基本形式： 
template<class F, class... Args>
constexpr auto bind(F&& f, Args&&... args);
参数说明如下：
第二种指定返回类型： 
template<class R, class F, class... Args>
constexpr auto bind(F&& f, Args&&... args);
自 C++11 起，std::bind() 生成一个转发调用包装器，调用此包装器等同于用部分绑定的参数调用f。从 C++20 开始，这些模板被标记为 constexpr，表明它们可以用于编译时常量表达式的场景。

std::bind() 返回一个类型未指定的函数对象 g，该对象在调用时表现为与 f 绑定了特定参数的可调用对象。如果 std::bind() 的结果对象被复制或移动，它的行为将根据成员对象的可复制或可移动性确定。

成员类型和函数：

C++ std::bind()的主要作用

std::bind() 在 C++ 中的主要作用是增强函数调用的灵活性和便利性，通过以下几个关键功能实现。

1) 参数绑定

std::bind() 允许将一个可调用对象的参数提前绑定。这意味着可以预先设置一些参数的值，生成一个新的可调用对象，这个对象在调用时只需提供剩余的未绑定参数。

2) 部分绑定

可以选择只绑定一部分参数，而其余参数在新的可调用对象被调用时提供。这种方式在编写需要参数预设但又保持一定灵活性的函数时非常有用。

3) 成员函数绑定

4) 与std::function配合使用

虽然 std::bind() 生成的可调用对象可以直接被调用，但在很多场景中，特别是需要类型消除或想统一不同形式可调用对象接口的场景中，这些可调用对象会被存储在 std::function 中。

总结来说，std::bind() 通过预设参数和改变函数调用的上下文（如将成员函数绑定到具体对象），为 C++ 程序提供了更高的灵活性和表达力，特别是在需要多样化参数处理和复杂函数调用的场景中。这使得代码更加模块化，更易于管理和维护。

C++ std::bind()应用场景

通常我们会结合 std::bind() 和 std::function 创建灵活的编程模式：
【实例展示】 
#include <iostream>
#include <functional>
#include <vector>
#include <typeinfo>

typedef std::function<void(int, int)> EventHandler;

class EventManager {
public:
    void registerHandler(EventHandler handler) {
        handlers.push_back(handler);
    }

    // 触发事件
    void triggerEvent(int eventType, int eventCode) {
        std::cout << "Triggering event with type: " << eventType << " and code: " << eventCode << std::endl;
        for (auto& handler : handlers) {
           handler(eventType, eventCode);
       }
    }

    // 交换处理器
    void swapHandlers(size_t index1, size_t index2) {
        if (index1 < handlers.size() && index2 < handlers.size()) {
            std::cout << "Swapping handlers: " << index1 << " and " << index2 << std::endl;
            handlers[index1].swap(handlers[index2]);
        }
    }

    // 打印所有处理器的类型信息
    void printHandlersTypeInfo() {
        for (auto& handler : handlers) {
            std::cout << "Handler type info: " << handler.target_type().name() << std::endl;
        }
    }

private:
    std::vector<EventHandler> handlers;
};

void handleEvent(int type, int code) {
    std::cout << "Global function handling event with type: " << type << " and code: " << code << std::endl;
}

class Processor {
public:
    void process(int type, int code) {
        std::cout << "Processing event with type: " << type << " and code: " << code << std::endl;
    }
};

int main() {
    EventManager manager;

    Processor processor;
    manager.registerHandler(handleEvent);
    EventHandler globalFunctionHandler = handleEvent;
    EventHandler boundMemberFunc = std::bind(&Processor::process, &processor, std::placeholders::_1, std::placeholders::_2);
    manager.registerHandler(boundMemberFunc);

    int importantValue = 42;
    manager.registerHandler([importantValue](int type, int code) {
        std::cout << "Lambda handling event with type: " << type << " and code: " << code << " and important value: " << importantValue << std::endl;
    });
    manager.printHandlersTypeInfo();
    std::cout << "      " << std::endl;
    // 判断是否绑定了 Processor::process
    auto targetMemberFunc = boundMemberFunc.target<void(Processor::*)(int, int)>();
    if (targetMemberFunc && *targetMemberFunc == &Processor::process) {
        std::cout << "The member function Processor::process is bound." << std::endl;
    } else {
        std::cout << "No matching target function bound for Processor::process." << std::endl;
    }

    // 判断是否绑定了 handleEvent
    auto targetGlobalFunc = globalFunctionHandler.target<void(*)(int, int)>();
    if (targetGlobalFunc && *targetGlobalFunc == handleEvent) {
        std::cout << "Global function handleEvent is bound." << std::endl;
    } else {
        std::cout << "No matching target function bound for handleEvent." << std::endl;
    }

    std::cout << " " << std::endl;
    manager.triggerEvent(11, 27);

    // 交换顺序
    manager.swapHandlers(0, 1);
    std::cout << "after swap" << std::endl;
    std::cout << " " << std::endl;
    manager.triggerEvent(11, 27);
}
运行结果为： 
Handler type info: PFviiE
Handler type info: St5_BindIFSt7_Mem_fnIM9ProcessorFviiEEPS1_St12_PlaceholderILi1EES6_ILi2EEEE
Handler type info: Z4mainEUliiE_

No matching target function bound for Processor::process.
Global function handleEvent is bound.

Triggering event with type: 11 and code: 27
Global function handling event with type: 11 and code: 27
Processing event with type: 11 and code: 27
Lambda handling event with type: 11 and code: 27 and important value: 42
Swapping handlers: 0 and 1
after swap

Triggering event with type: 11 and code: 27
Processing event with type: 11 and code: 27
Global function handling event with type: 11 and code: 27
Lambda handling event with type: 11 and code: 27 and important value: 42
这个示例展示了如何使用 C++ 中的 std::function 和 std::bind() 以及 Lambda 表达式来构建一个灵活的事件管理系统。

我们创建了一个 EventManager 类，它能够注册不同类型的事件处理器，如全局函数、绑定的成员函数和 Lambda 表达式，并能触发事件、交换处理器的顺序、打印处理器的类型信息：
值得注意的是，std::function 的 target() 方法的使用是有限制的，主要包括：
因此，std::function 的 target() 方法主要用于检测和提取全局函数或静态成员函数的指针，而对于更复杂的可调用对象类型，如通过 std::bind() 绑定的成员函数或 Lambda 表达式，target() 方法通常不可用。如果需要在 std::function 中存储和识别这类复杂的可调用对象，可能需要考虑使用其他机制，如设计时的接口约定或其他类型识别技术。

通过这个综合示例，我们不仅可以看到 std::function、std::bind 和 Lambda 表达式的实际应用，还能深入理解事件驱动编程模型的灵活性和强大功能。

相关文章