扩充mem_fun和mem_fun_ref 用于关联容器

        

       STL提供了成员函数适配器，程序员可以不用写显式循环就能调用线性容器中所有元素的0员函数或一元函数。但是对于关联容器如map就不存在的这样的成员函数适配器可以使用。我猜想STL不对map提供成员函数适配器的原因是：C++标准并未规定关联容器的实现方式，虽然目前所知的STL显现中都是使用pair存贮关联容器的每个元素。

鉴于目前我们使用的STL实现中，在关联容器中都是存贮了一个个的pair，可以在这个假定下扩充mem_fun和mem_fun_ref。

namespace std

{

template <typename T,typename U,typename Result>

class mem_fun_map_t : public std::unary_function< std::pair<const T,U*>,Result >

{

public :

    mem_fun_map_t(Result (U::*pMemFun)()) : m_pMemFun(pMemFun)

    {}

 

    Result operator()(std::pair<const T,U*> &pr) const

    {

       return (pr.second->*m_pMemFun)();

    }

 

private :

    Result (U::*m_pMemFun)();

};

 

template <typename T,typename U,typename Result,typename Arg>

class mem_fun1_map_t : public std::binary_function< std::pair<const T,U*>,Arg,Result>

{

public :

    mem_fun1_map_t(Result (U::*pMemFun)(Arg)) : m_pMemFun(pMemFun)

    {}

 

    Result operator()(std::pair<const T,U*> &pr,Arg arg) const

    {

       return (pr.second->*m_pMemFun)(arg);

    }

 

private :

    Result (U::*m_pMemFun)(Arg);

};

 

template <typename T,typename U,typename Result>

class mem_fun_map_ref_t : public std::unary_function< std::pair<const T,U>,Result >

{

public :

    mem_fun_map_ref_t(Result (U::*pMemFun)()) : m_pMemFun(pMemFun)

    {}

 

    Result operator()(std::pair<const T,U> &pr) const

    {

       return (pr.second.*m_pMemFun)();

    }

 

private :

    Result (U::*m_pMemFun)();

};

 

template <typename T,typename U,typename Result,typename Arg>

class mem_fun1_map_ref_t : public std::binary_function< std::pair<const T,U>,Arg,Result>

{

public :

    mem_fun1_map_ref_t(Result (U::*pMemFun)(Arg)) : m_pMemFun(pMemFun)

    {}

 

    Result operator()(std::pair<const T,U> &pr,Arg arg) const

    {

       return (pr.second.*m_pMemFun)(arg);

    }

 

private :

    Result (U::*m_pMemFun)(Arg);

};

 

template <typename T,typename U,typename Result>

mem_fun_map_t<T,U,Result> mem_fun_map(Result (U::*pMemFun)())

{

    return mem_fun_map_t<T,U,Result>(pMemFun);

}

 

template <typename T,typename U,typename Result,typename Arg>

mem_fun1_map_t<T,U,Result,Arg> mem_fun_map(Result (U::*pMemFun)(Arg))

{

    return mem_fun1_map_t<T,U,Result,Arg>(pMemFun);

}

 

template <typename T,typename U,typename Result>

mem_fun_map_ref_t<T,U,Result> mem_fun_map_ref(Result (U::*pMemFun)())

{

    return mem_fun_map_ref_t<T,U,Result>(pMemFun);

}

 

template <typename T,typename U,typename Result,typename Arg>

mem_fun1_map_ref_t<T,U,Result,Arg> mem_fun_map_ref(Result (U::*pMemFun)(Arg))

{

    return mem_fun1_map_ref_t<T,U,Result,Arg>(pMemFun);

}

 

}

//test codes

class MyClass

{

public :

    MyClass(){}

    void MemFun()

    {

       std::cout << "MyClass::Fun" << std::endl;

    }

   

    int UnaryMemFun(int arg)

    {

       std::cout << arg << std::endl;

       return arg;

    }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

 

    std::map<int,MyClass*> ptr_map;

    ptr_map.insert(std::make_pair(0,new MyClass()));

    ptr_map.insert(std::make_pair(1,new MyClass()));

    ptr_map.insert(std::make_pair(2,new MyClass()));

 

    //test mem_fun_map_t

    std::for_each(ptr_map.begin(),

       ptr_map.end(),

       std::mem_fun_map<int>(MyClass::MemFun));

 

    //test mem_fun1_map_t

    std::for_each(ptr_map.begin(),

       ptr_map.end(),

       std::bind2nd(std::mem_fun_map<int>(MyClass::UnaryMemFun),2)

       );

 

    std::map<int,MyClass> value_map;

    value_map.insert(std::make_pair(0,MyClass()));

    value_map.insert(std::make_pair(1,MyClass()));

    value_map.insert(std::make_pair(2,MyClass()));

 

    //test mem_fun_map_ref_t

    std::for_each(value_map.begin(),

       value_map.end(),

       std::mem_fun_map_ref<int>(MyClass::MemFun));

 

    //test mem_fun1_map_ref_t

    std::for_each(value_map.begin(),

       value_map.end(),

       std::bind2nd(std::mem_fun_map_ref<int>(MyClass::UnaryMemFun),2)

       );

 

    system("pause");

 

    return 0;

}