C++进阶专栏:http://t.csdnimg.cn/5mV9r
目录
1.简介
函数模板std :: mem_fn生成指向成员的指针的包装对象,该对象可以存储,复制和调用指向成员的指针。 调用std :: mem_fn时,可以使用对象的引用和指针(包括智能指针)。
我理解std::mem_fn 把一个成员函数或成员变量转换成一个可调用的函数对象。函数对象的功能是借助成员函数或成员变量来实现的。这个在我们后面讲它的实现原理时你可以很清楚的理解它。
2.使用
用 std::mem_fn
来存储并执行成员函数和成员对象:
#include <functional>
#include <iostream>
#include <memory>
struct Foo
{
void display_greeting()
{
std::cout << "你好。\n";
}
void display_number(int i)
{
std::cout << "数字:" << i << '\n';
}
int add_xy(int x, int y)
{
return data + x + y;
}
template<typename... Args> int add_many(Args... args)
{
return data + (args + ...);
}
auto add_them(auto... args) // 需要 C++20
{
return data + (args + ...);
}
int data = 7;
};
int main()
{
auto f = Foo{};
auto greet = std::mem_fn(&Foo::display_greeting);
greet(f);
auto print_num = std::mem_fn(&Foo::display_number);
print_num(f, 42);
auto access_data = std::mem_fn(&Foo::data);
std::cout << "data:" << access_data(f) << '\n';
auto add_xy = std::mem_fn(&Foo::add_xy);
std::cout << "add_xy:" << add_xy(f, 1, 2) << '\n';
// 用于智能指针
auto u = std::make_unique<Foo>();
std::cout << "access_data(u):" << access_data(u) << '\n';
std::cout << "add_xy(u, 1, 2):" << add_xy(u, 1, 2) << '\n';
// 用于带形参包的成员函数模板
auto add_many = std::mem_fn(&Foo::add_many<short, int, long>);
std::cout << "add_many(u, ...):" << add_many(u, 1, 2, 3) << '\n';
auto add_them = std::mem_fn(&Foo::add_them<short, int, float, double>);
std::cout << "add_them(u, ...):" << add_them(u, 5, 7, 10.0f, 13.0) << '\n';
}
输出:
你好。
数字:42
data:7
add_xy:10
access_data(u):7
add_xy(u, 1, 2):10
add_many(u, ...):13
add_them(u, ...):42
上面代码变量greet、print_num、add_xy 、add_many、add_them用于存储Foo的类成员函数,access_data用于存储Foo的成员变量,最后使用了统一的调用格式Fn(, , ,...)来完成对函数的调用或成员变量的访问。
3.实现原理
源码面前无秘密,直接上源码(VS2019):
template <class _Memptr>
class _Mem_fn : public _Weak_types<_Memptr> {
private:
_Memptr _Pm;
public:
constexpr explicit _Mem_fn(_Memptr _Val) noexcept : _Pm(_Val) {}
template <class... _Types>
_CONSTEXPR20 auto operator()(_Types&&... _Args) const
noexcept(noexcept(_STD invoke(_Pm, _STD forward<_Types>(_Args)...)))
-> decltype(_STD invoke(_Pm, _STD forward<_Types>(_Args)...)) {
return _STD invoke(_Pm, _STD forward<_Types>(_Args)...);
}
};
template <class _Rx, class _Ty>
_NODISCARD _CONSTEXPR20 _Mem_fn<_Rx _Ty::*> mem_fn(_Rx _Ty::*_Pm) noexcept {
return _Mem_fn<_Rx _Ty::*>(_Pm);
}
从上面的实现可以看出:
1.std::mem_fn是模版函数,接收的参数_Pm是的struct或class的成员指针,这个指针可能是函数指针,也可能是成员变量指针;从这里就限制了std::mem_fn不能用全局函数指针。
2._Mem_fn是模版类,重载了operator(), 这就是仿函数的实现方式。类_Mem_fn的_Pm存储了类成员指针,然后最终通过std::invoke实现函数调用或成员变量访问。
3.std::invoke 是 C++17标准库中引入的一个函数模板,它提供了一种统一的调用语法,无论是调用普通函数、函数指针、类成员函数指针、仿函数、std::function、类成员还是lambda表达式,都可以使用相同的方式进行调用; 更多详细的讲解可参考我的另外一篇博客。
4.使用注意
不支持的场景
不支持全局函数
不支持类protected访问权限的成员(函数或数据)
不支持类private访问权限的成员(函数或数据)
支持的场景
传入类对象
传入引用对象
传入右值
传入对象指针
传入智能指针std::shared_ptr
传入智能指针std::unique_ptr
传入派生类对象
带参数的成员函数
示例如下:
#include <functional>
#include <iostream>
int Add(int a, int b)
{
return a + b;
}
class Age
{
public:
Age(int default = 7879) : m_age(default)
{}
bool compare(const Age& t) const
{
return m_age < t.m_age;
}
void print() const
{
std::cout << m_age << ' ';
}
int m_age;
protected:
void add(int n)
{
m_age += n;
}
private:
void sub(int m)
{
m_age -= m;
}
};
class DerivedAge : public Age
{
public:
DerivedAge(int default = 22) : Age(default)
{}
};
int main(int argc, char* argv[])
{
// 0.不支持的示例
{
// 1.不支持全局函数
// auto globalFunc = std::mem_fn(Add); // ERROR: 语法无法通过
// 2.不支持类protected访问权限的函数
// auto addFunc = std::mem_fn(&Age::add); // ERROR: 语法无法通过
// 3.不支持类private访问权限的函数
// auto subFunc = std::mem_fn(&Age::sub); // ERROR: 语法无法通过
}
// 1.成员函数示例
{
auto memFunc = std::mem_fn(&Age::print);
// 方式一:传入类对象
Age obja{ 18 };
memFunc(obja);
Age& refObj = obja;
refObj.m_age = 28;
// 方式二:传入引用对象
memFunc(refObj);
// 方式三:传入右值
Age objb{ 38 };
memFunc(std::move(objb));
// 方式四:传入对象指针
Age objc{ 48 };
memFunc(&objc);
// 方式五:传入智能指针std::shared_ptr
std::shared_ptr<Age> pAge1 = std::make_shared<Age>(58);
memFunc(pAge1);
// 方式六:传入智能指针std::unique_ptr
std::unique_ptr<Age> pAge2 = std::make_unique<Age>(68);
memFunc(pAge2);
// 方式七:传入派生类对象
DerivedAge aged{ 78 };
memFunc(aged);
// 方式八:带参数成员函数
auto memFuncWithParams = std::mem_fn(&Age::compare);
std::cout << memFuncWithParams(Age{ 25 }, Age{ 35 }) << std::endl;
}
std::cout << std::endl;
// 2.成员变量示例
{
auto memData = std::mem_fn(&Age::m_age);
// 方式一:传入类对象
Age obja{ 19 };
std::cout << memData(obja) << ' ';
Age& refObj = obja;
refObj.m_age = 29;
// 方式二:传入引用对象
std::cout << memData(refObj) << ' ';
// 方式三:传入右值
Age objb{ 39 };
std::cout << memData(std::move(objb)) << ' ';
// 方式四:传入对象指针
Age objc{ 49 };
std::cout << memData(&objc) << ' ';
// 方式五:传入智能指针std::shared_ptr
std::shared_ptr<Age> pAge1 = std::make_shared<Age>(59);
std::cout << memData(pAge1) << ' ';
// 方式六:传入智能指针std::unique_ptr
std::unique_ptr<Age> pAge2 = std::make_unique<Age>(69);
std::cout << memData(pAge2) << ' ';
// 方式七:传入派生类对象
DerivedAge aged{ 79 };
std::cout << memData(aged) << ' ';
}
//3.写法差别
// 以前写法
{
std::vector<Age> ages{ 1, 7, 19, 27, 39, 16, 13, 18 };
std::sort(ages.begin(), ages.end(), [&](const Age& objA, const Age& objB) {
return return objA.m_age < objB.m_age;;
});
for (auto item : ages)
{
item.print();
}
std::cout << std::endl;
}
// 利用std::mem_fn写法
{
std::vector<Age> ages{ 100, 70, 290, 170, 390, 160, 300, 180 };
std::sort(ages.begin(), ages.end(), std::mem_fn(&Age::compare));
std::for_each(ages.begin(), ages.end(), std::mem_fn(&Age::print));
std::cout << std::endl;
}
return 0;
}
5.总结
std::mem_fn
允许我们将成员函数、数据成员或指向成员的指针转换为可调用的对象。- 这使得我们可以更加灵活地处理成员函数,特别是在需要将其作为回调或策略参数传递时。
- 通过
std::mem_fn
,我们可以避免直接使用函数指针或成员指针,从而简化代码并提高可读性。 std::mem_fn
返回的对象可以存储并传递给其他函数或对象,以便稍后使用。
需要注意的是,std::mem_fn
生成的函数对象需要接收一个对象实例作为第一个参数(对于非静态成员函数),然后才能调用该成员函数。对于数据成员,它返回的是对该成员的引用或指针,取决于数据成员的类型。
参考: