文章目录
非静态成员函数不能直接作为匿名函数的参数，原因是它们具有一个隐式的 this 指针，这个指针指向调用该成员函数的对象。因此，在将非静态成员函数作为函数参数时，你必须明确指定对象的实例，否则编译器会无法确定 this 指针。- 但是，
可以通过一些方法间接地实现这一功能，比如通过捕获对象指针或引用来解决这个问题。如通过捕获对象或使用std::mem_fn、std::bind等技巧，间接地传递非静态成员函数
1. 捕获对象来使用非静态成员函数
示例：通过捕获对象来使用非静态成员函数
#include <iostream>
#include <vector>
#include <algorithm>
class MyClass {
public:
void print(int x) {
std::cout << "Value: " << x << std::endl;
}
};
int main() {
MyClass obj;
std::vector<int> nums = {1, 5, 3, 9, 7};
// 使用 lambda 表达式捕获 obj，并调用非静态成员函数
std::for_each(nums.begin(), nums.end(), [&obj](int num) {
obj.print(num); // 调用非静态成员函数
});
return 0;
}
在这个例子中，lambda 捕获了对象 obj，并通过 obj.print(num) 调用了 MyClass 的非静态成员函数 print。这样，我们就能够在 lambda 中使用成员函数了。
直接将非静态成员函数作为参数的困难：
假设我们尝试直接传递一个非静态成员函数作为 std::for_each 的参数，代码会报错：
std::for_each(nums.begin(), nums.end(), &MyClass::print); // 错误
错误的原因是非静态成员函数需要一个对象的上下文来调用，因为它隐式地包含 this 指针。
解决方案：
你可以使用 std::mem_fn 或 std::bind 来间接地将成员函数与对象绑定在一起，从而使其能够作为参数传递。
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
class MyClass {
public:
void print(int x) {
std::cout << "Value: " << x << std::endl;
}
};
int main() {
MyClass obj;
std::vector<int> nums = {1, 5, 3, 9, 7};
// 使用 std::mem_fn 将成员函数绑定到对象
std::for_each(nums.begin(), nums.end(), std::mem_fn(&MyClass::print, &obj));
return 0;
}
通过 std::mem_fn，你可以将成员函数 &MyClass::print 和对象 &obj 绑定在一起，形成一个可调用的函数对象。
总结
虽然非静态成员函数不能直接作为匿名函数的参数，但你可以通过捕获对象或使用 std::mem_fn、std::bind 等技巧，间接地传递非静态成员函数。
mem_fn_76">2. std::mem_fn函数详讲
std::mem_fn 是 C++ 标准库中的一个工具，它用于将成员函数转换为可调用的函数对象。它的作用是将一个成员函数和一个对象绑定在一起，从而使得我们可以像调用普通函数一样调用成员函数。
用法和基本概念
std::mem_fn 将成员函数转换为一个函数对象（可调用对象），这个函数对象能够接受一个对象指针或引用，并在其上调用成员函数。使用 std::mem_fn 后，你就可以通过该函数对象来调用成员函数，而不需要直接提供 this 指针。
语法
std::mem_fn(&Class::member_function)
其中：
&Class::member_function是你要转换的成员函数指针。
返回值是一个可以接受对象指针或对象引用的可调用对象。你可以将这个函数对象传递给 STL 算法或其他函数，直接调用成员函数。
示例：基本使用
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
class MyClass {
public:
void print(int x) const {
std::cout << "Value: " << x << std::endl;
}
};
int main() {
MyClass obj;
std::vector<int> nums = {1, 5, 3, 9, 7};
// 使用 std::mem_fn 创建一个可调用的函数对象
auto print_fn = std::mem_fn(&MyClass::print);
// 使用 std::for_each 和 std::mem_fn 调用成员函数
std::for_each(nums.begin(), nums.end(), [&obj, print_fn](int num) {
print_fn(obj, num); // 通过 print_fn 调用 obj.print(num)
});
return 0;
}
解释：
std::mem_fn(&MyClass::print)返回一个可调用对象print_fn，它代表了MyClass的print成员函数。print_fn在调用时需要一个MyClass类型的对象（obj），然后是成员函数的参数（num）。- 通过
print_fn(obj, num)，我们可以调用obj.print(num)。
mem_fn__lambda__129">std::mem_fn 与 lambda 的比较
在很多情况下，你可以用 std::mem_fn 来替代 lambda，尤其是在你不想显式捕获对象时。比较下面两种方式：
mem_fn_133">使用 std::mem_fn：
std::for_each(nums.begin(), nums.end(), std::mem_fn(&MyClass::print, &obj));
使用 lambda 表达式：
std::for_each(nums.begin(), nums.end(), [&obj](int num) {
obj.print(num);
});
这两种方式的效果是相同的，区别在于 std::mem_fn 是标准库提供的工具，而 lambda 是 C++11 引入的一种语法糖。
mem_fn__149">使用 std::mem_fn 绑定静态成员函数
std::mem_fn 只适用于非静态成员函数。如果你想处理静态成员函数，直接使用成员函数指针就可以，而不需要 std::mem_fn。静态成员函数不需要 this 指针，因此不需要通过对象来调用。
#include <iostream>
class MyClass {
public:
static void print(int x) {
std::cout << "Static value: " << x << std::endl;
}
};
int main() {
// 静态成员函数可以直接使用
auto static_print = &MyClass::print;
static_print(42);
return 0;
}
