c++ 类成员指针及其与`std::bind`交互使用的简单说明

关于C++类成员指针及其与std::bind交互使用的简单说明
***注：用到的时候查看，一般用不到，直接划走 ***

---

一、类成员指针

类成员指针分为两种：指向成员变量的指针和指向成员函数的指针。它们需要通过类的实例来访问具体成员。

1. 指向成员变量的指针

class MyClass {
public:
    int value;
};

int MyClass::*ptr = &MyClass::value; // 定义成员变量指针

// 使用示例
MyClass obj;
obj.*ptr = 42; // 通过指针访问成员变量

2. 指向成员函数的指针

class MyClass {
public:
    void print() { std::cout << "Hello" << std::endl; }
};

void (MyClass::*funcPtr)() = &MyClass::print; // 定义成员函数指针

// 使用示例
MyClass obj;
(obj.*funcPtr)(); // 输出: Hello

---

二、类成员指针与std::bind的交互

std::bind可以将成员指针与对象实例绑定，生成一个可调用对象。以下是常见用法：

1. 绑定成员函数

#include <functional>
using namespace std::placeholders; // 用于占位符 _1, _2...

class MyClass {
public:
    void setValue(int v) { value = v; }
    int value;
};

MyClass obj;

// 绑定成员函数和对象实例
auto setter = std::bind(&MyClass::setValue, &obj, _1);
setter(42); // 等价于 obj.setValue(42)

// 绑定成员函数并延迟传递参数
auto delayedSetter = std::bind(&MyClass::setValue, &obj, 100);
delayedSetter(); // 等价于 obj.setValue(100)

2. 绑定成员变量

// 绑定成员变量
auto getValue = std::bind(&MyClass::value, &obj);
int val = getValue(); // 等价于 obj.value

3. 绑定重载成员函数

若成员函数有重载，需显式指定函数类型：

class MyClass {
public:
    void func(int) {}
    void func(double) {}
};

// 显式选择重载版本
auto boundFunc = std::bind(
    static_cast<void (MyClass::*)(int)>(&MyClass::func), 
    &obj, 
    _1
);
boundFunc(42); // 调用 func(int)

4. 绑定智能指针管理的对象

#include <memory>
auto objPtr = std::make_shared<MyClass>();
auto boundFunc = std::bind(&MyClass::print, objPtr);
boundFunc(); // 安全调用 objPtr->print()

---

三、注意事项

1. 对象生命周期：
   若绑定的是裸指针（&obj），需确保对象在调用时仍然有效。推荐使用shared_ptr或std::ref管理对象。

2. 占位符的使用：
   _1表示第一个参数，_2表示第二个参数，依此类推。例如：

   auto setter = std::bind(&MyClass::setValue, _1, _2);
   setter(&obj, 42); // 等价于 obj.setValue(42)
   

3. 与Lambda的对比：
   现代C++更推荐使用Lambda表达式，因其更简洁且类型安全：

   auto lambdaSetter = [&obj](int v) { obj.setValue(v); };
   lambdaSetter(42);
   

---

四、完整示例

#include <iostream>
#include <functional>
using namespace std::placeholders;

class Calculator {
public:
    int add(int a, int b) { return a + b; }
    int value = 0;
};

int main() {
    Calculator calc;

    // 绑定成员函数
    auto addFunc = std::bind(&Calculator::add, &calc, _1, _2);
    std::cout << addFunc(3, 4) << std::endl; // 输出: 7

    // 绑定成员变量
    auto getValue = std::bind(&Calculator::value, &calc);
    std::cout << getValue() << std::endl; // 输出: 0

    // 绑定智能指针对象
    auto calcPtr = std::make_shared<Calculator>();
    auto smartAdd = std::bind(&Calculator::add, calcPtr, _1, _2);
    std::cout << smartAdd(5, 6) << std::endl; // 输出: 11

    return 0;
}

---

五、总结

• 类成员指针允许通过指针间接访问类的成员，需结合对象实例使用。
• std::bind 可以将成员指针与对象绑定，生成灵活的可调用对象。
• 推荐优先使用Lambda表达式，但在需要兼容旧代码或特定场景下，std::bind仍是一个强大的工具。