C++类成员指针的实现示例

#include <iostream>
using namespace std;

class Person {
public:
    string name;
    int age;
    static int count; // 静态数据成员（特殊情况）
};
int Person::count = 0; // 静态成员初始化

int main() {
    // 1. 定义并赋值：指向Person的age成员
    int Person::*p_age = &Person::age;
    // 指向Person的name成员
    string Person::*p_name = &Person::name;

    // 2. 绑定对象访问（用.*运算符）
    Person p1{"Alice", 20};
    cout << "Name: " << p1.*p_name << endl; // 输出Alice
    cout << "Age: " << p1.*p_age << endl;   // 输出20

    // 3. 绑定对象指针访问（用->*运算符）
    Person* p2 = &p1;
    p2->*p_age = 21; // 修改age
    cout << "New Age: " << p2->*p_age << endl; // 输出21

    // 4. 静态数据成员指针（特殊：和普通指针一样）
    int* p_count = &Person::count; // 无需Person::*，直接用普通指针
    *p_count = 100;
    cout << "Count: " << Person::count << endl; // 输出100

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Calculator {
public:
    int add(int a, int b) { return a + b; }
    int sub(int a, int b) const { return a - b; } // const成员函数
    static int mul(int a, int b) { return a * b; } // 静态成员函数
};

int main() {
    // 1. 指向非const成员函数
    int (Calculator::*p_add)(int, int) = &Calculator::add;
    // 2. 指向const成员函数（必须加const限定）
    int (Calculator::*p_sub)(int, int) const = &Calculator::sub;

    // 3. 绑定对象调用（.*运算符）
    Calculator calc;
    cout << "Add: " << (calc.*p_add)(10, 5) << endl; // 输出15
    cout << "Sub: " << (calc.*p_sub)(10, 5) << endl; // 输出5

    // 4. 绑定对象指针调用（->*运算符）
    Calculator* p_calc = &calc;
    cout << "Add via ptr: " << (p_calc->*p_add)(20, 3) << endl; // 输出23

    // 5. 静态成员函数指针（特殊：和普通函数指针兼容）
    int (*p_mul)(int, int) = &Calculator::mul;
    cout << "Mul: " << p_mul(4, 5) << endl; // 输出20

    return 0;
}

#include <iostream>
#include <functional> // 必须包含
using namespace std;

class Printer {
public:
    void print(string msg, int num) {
        cout << msg << ": " << num << endl;
    }
};

int main() {
    Printer p;
    // 绑定成员函数+对象，固定部分参数（也可留空参数用placeholders）
    auto func = bind(&Printer::print, &p, "Number", placeholders::_1);
    // 调用：只需传未绑定的参数
    func(100); // 输出Number: 100

    return 0;
}

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

class Math {
public:
    int square(int x) { return x * x; }
};

int main() {
    Math m;
    // 封装为std::function：参数列表要匹配成员函数（隐含this已绑定）
    function<int(int)> f = bind(&Math::square, &m, placeholders::_1);
    cout << f(5) << endl; // 输出25

    // 也可直接用lambda（更简洁，见方式3）
    function<int(int)> f2 = [&m](int x) { return m.square(x); };
    cout << f2(6) << endl; // 输出36

    return 0;
}

#include <iostream>
#include <thread> // 用于演示线程调用成员函数
using namespace std;

class Worker {
public:
    void work(int id) {
        cout << "Worker " << id << " is running" << endl;
    }
};

int main() {
    Worker w;
    // 1. 普通调用：lambda捕获对象
    auto func = [&w]() { w.work(1); };
    func(); // 输出Worker 1 is running

    // 2. 线程调用成员函数（核心场景）
    thread t([&w]() { w.work(2); });
    t.join(); // 输出Worker 2 is running

    // 3. 捕获this（成员函数内调用）
    class Test {
    public:
        void call_self() {
            auto f = [this]() { this->work(3); };
            f(); // 输出Worker 3 is running
        }
        void work(int id) { cout << "Test Worker " << id << endl; }
    };
    Test tst;
    tst.call_self();

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class Filter {
public:
    bool is_even(int x) { return x % 2 == 0; }
};

int main() {
    vector<int> nums = {1,2,3,4,5};
    Filter f;
    // 用lambda包裹成员函数，作为find_if的谓词
    auto it = find_if(nums.begin(), nums.end(), [&f](int x) {
        return f.is_even(x);
    });
    if (it != nums.end()) {
        cout << "First even number: " << *it << endl; // 输出2
    }

    return 0;
}