本文是基于gcc-4.9.0的源代码进行分析，std::mem_fn是C++11才加入标准的，所以低版本的gcc源码是没有std::mem_fn的，建议选择4.9.0或更新的版本去学习，不同版本的gcc源码差异应该不小，但是原理和设计思想的一样的，下面给出源码下载地址
http://ftp.gnu.org/gnu/gcc
算法是C++标准库中非常重要的组成部分，C++通过算法+容器的方式将数据结构和算法进行了分离，这样可以使用户编写代码的时候获得最大限度的灵活性。假设我们有如下类：
class Age
{
public:
Age(int v)
:m_age(v)
{
}
bool compare(const Age& t) const
{
return m_age < t.m_age;
}
int m_age;
};
我们可以非常方便地使用vector来保存Age对象，如下：
std::vector<Age> ages{1, 7, 19, 27, 39, 16, 13, 18};
然后非常方便的利用排序算法进行排序
std::sort(ages.begin(), ages.end(), compare);
代码中的compare是额外定义的一个比较函数，通过这个函数来选择比较的对象并决定比较的结果
bool compare(const Age& t1, const Age& t2)
{
return t1.compare(t2);
}
严格来讲，算法中要求的并不是函数，而是一个可调用对象。C++中的可调用对象包括函数、函数对象、Lambda表达式、参数绑定等等，它们都可以作为算法的传入参数，但是如果我们按如下来传入参数的话，则会在编译过程中出现错误
std::sort(ages.begin(), ages.end(), &Age::compare);
因为&Age::compare是类成员函数，并非一个可调用对象，如果我们要将它作为比较的参数传递进去的话，就得用std::mem_fn修饰它，如下所示
std::sort(ages.begin(), ages.end(), std::mem_fn(&Age::compare));
从上面的例子可以看到，std::mem_fn的作用就是将类的成员函数转换为一个可调用对象，那么问题来了，std::mem_fn是如何实现这种功能的呢？下面让我们通过分析源码，来揭开std::mem_fn的神秘面纱。
std::mem_fn位于libstdc++-v3\include\std\functional中
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
从代码中可知std::mem_fn是一个模板函数，传入参数为指向_Class类里面的某个成员函数的指针，其返回值为_Tp，而该模板函数返回的值为_Mem_fn<_Tp _Class::*>，接下来看一下_Mem_fn的实现
std::_Mem_fn位于libstdc++-v3\include\std\functional中
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template<typename _Tp, typename... _Args>
_Res _M_call(_Tp&& __object, const volatile _Class *, _Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args>
using _RequireValidArgs = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2 = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>, _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3 = _Require<is_base_of<_Class, _Tp>, _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) {}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res operator()(_Class& __object, _Args&&... __args) const
{
return (__object.*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res operator()(_Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res operator()(_Class* __object, _Args&&... __args) const
{
return (__object->*__pmf)(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args, typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{
return operator()(__ref.get(), std::forward<_Args>(__args)...);
}
private:
_Functor __pmf;
};
从源代码中可以看出以下几点信息：
template<typename _Tp, typename... _Args>
_Res _M_call(_Tp&& __object, const volatile _Class *, _Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{
return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...);
}
示例代码如下，从上面的一大段分析可以知道，我们传入的ages[2]就是之前一直分析的那个用于调用类成员函数的那个传入对象，而ages[3]就是bool Age::compare(const Age& t)所需要的正常的传入参数了，也就是上面的可变参数里面的值。至此std::mem_fn源码也就分析完毕了
#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;
}
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};
bool ret = std::mem_fn(&Age::compare)(ages[2], ages[3]);
//std::sort(ages.begin(), ages.end(), std::mem_fn(&Age::compare));
return 0;
}
std::mem_fn在函数式编程中的作用是非常大的，我们可以使用std::mem_fn生成指向类成员函数的指针的包装对象，该对象可以存储，复制和调用指向类成员函数的指针。而我们实际使用的是std::mem_fn的返回值std::_Mem_fn这个类，而我们在调用std::_Mem_fn中重载的()方法时，可以使用类对象、派生类对象、对象引用（包括std::reference_wrapper）、对象的右值引用、指向对象的指针（包括智能指针）来作为第一个参数传递进去。
