std::mem_fn
目录
std::mem_fn
1. 不支持的场景
1.1 不支持全局函数
1.2 不支持类protected访问权限的成员（函数或数据）
1.3 不支持类private访问权限的成员（函数或数据）
2. 支持的场景
2.1 传入类对象
2.2 传入引用对象
2.3 传入右值
2.4 传入对象指针
2.5 传入智能指针std::shared_ptr
2.6 传入智能指针std::unique_ptr
2.7 传入派生类对象
2.8 带参数的成员函数
3. 场景示例代码
#include <functional>
#include <iostream>
int Add(int a, int b)
{
return a + b;
}
class Age
{
public:
Age(int default = 12) : 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) << ' ';
}
return 0;
}
/* run output:
18 28 38 48 58 68 78 1
19 29 39 49 59 69 79
*/
4. 应用示例
4.1 以前写法
4.2 使用std::mem_fn写法
4.3 示例代码
#include <functional>
#include <iostream>
#include <algorithm>
#include <vector>
class Age
{
public:
Age(int v) : m_age(v)
{}
bool compare(const Age& t) const
{
return m_age < t.m_age;
}
void print() const
{
std::cout << m_age << ' ';
}
int m_age;
};
bool compare(const Age& t1, const Age& t2)
{
return t1.compare(t2);
}
int main(int argc, char* argv[])
{
// 以前写法
{
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 compare(objA, objB);
});
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;
}
/* run output:
1 7 13 16 18 19 27 39
70 100 160 170 180 290 300 390
*/
