stl function扩展(一)
#ifndef _FUNCTION_LIB_H_
#define _FUNCTION_LIB_H_
#include <functional>
namespace function_lib
{
/*
*仿函数功能：将二元仿函数的第一个参数绑定，使之成为一元仿函数；
*/
template<class _Fn2>
class binder1st
: public std::binary_function<typename _Fn2::first_argument_type,
typename _Fn2::second_argument_type,
typename _Fn2::result_type>
{
public:
typedef std::binary_function<typename _Fn2::first_argument_type,
typename _Fn2::second_argument_type,
typename _Fn2::result_type> _Base;
typedef typename _Base::first_argument_type first_argument_type;
typedef typename _Base::second_argument_type second_argument_type;
typedef typename _Base::result_type result_type;
binder1st(_Fn2& _Func,
const first_argument_type &_Left)
: op(_Func), value(_Left)
{
}
result_type operator()(const second_argument_type &_Right)
{
return (op(value, _Right));
}
result_type operator()(second_argument_type &_Right)
{
return (op(value, _Right));
}
protected:
_Fn2 op;
typename _Fn2::first_argument_type value;
};
template<class _Fn2,
class _Ty>
function_lib::binder1st<_Fn2> bind1st(_Fn2& _Func, const _Ty& _Left)
{
typename _Fn2::first_argument_type _Val(_Left);
return (function_lib::binder1st<_Fn2>(_Func, _Val));
}
/*
*仿函数功能：将二元仿函数的第一个参数绑定，使之成为一元仿函数；
*/
template<class _Fn2>
class const_binder1st
: public std::binary_function<typename _Fn2::first_argument_type,
typename _Fn2::second_argument_type,
typename _Fn2::result_type>
{
public:
typedef std::binary_function<typename _Fn2::first_argument_type,
typename _Fn2::second_argument_type,
typename _Fn2::result_type> _Base;
typedef typename _Base::first_argument_type first_argument_type;
typedef typename _Base::second_argument_type second_argument_type;
typedef typename _Base::result_type result_type;
const_binder1st(_Fn2 &_Func,
const first_argument_type &_Left)
: op(_Func), value(_Left)
{
}
result_type operator()(second_argument_type &_Right)
{
return (op(value, _Right));
}
protected:
_Fn2 op;
typename _Fn2::first_argument_type value;
};
template<class _Fn2,
class _Ty>
function_lib::const_binder1st<_Fn2> const_bind1st(_Fn2 &_Func, const _Ty& _Left)
{
typename _Fn2::first_argument_type _Val(_Left);
return (function_lib::const_binder1st<_Fn2>(_Func, _Val));
}
/*
*仿函数功能：通过指针，调用一个对象的成员函数，并传递一个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _Arg>
class obj_mem_fun_t : public std::unary_function<_Arg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_Arg);
obj_mem_fun_t(_Ty *_pObj, _MemFunPtr _pMemFunPtr)
: m_pObj(_pObj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(const _Arg &_arg)
{
(m_pObj->*m_pMemFunPtr)(_arg);
}
void operator ()(_Arg &_arg)
{
(m_pObj->*m_pMemFunPtr)(_arg);
}
private:
_Ty *m_pObj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _Arg>
obj_mem_fun_t<_Result, _Ty, _Arg>
obj_mem_fun(_Ty *_pObj, _Result (_Ty::*_pm)(_Arg))
{
return obj_mem_fun_t<_Result, _Ty, _Arg>(_pObj, _pm);
}
/*
*仿函数功能：通过指针，调用一个对象的成员函数，并传递两个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
class obj_mem_fun1_t : public std::binary_function<_LeftArg, _RightArg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_LeftArg, _RightArg);
obj_mem_fun1_t(_Ty *_pObj, _MemFunPtr _pMemFunPtr)
: m_pObj(_pObj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(const _LeftArg &_left, const _RightArg &_right)
{
(m_pObj->*m_pMemFunPtr)(_left, _right);
}
void operator ()(_LeftArg &_left, _RightArg &_right)
{
(m_pObj->*m_pMemFunPtr)(_left, _right);
}
private:
_Ty *m_pObj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
obj_mem_fun1_t<_Result, _Ty, _LeftArg, _RightArg>
obj_mem_fun(_Ty *_pObj, _Result (_Ty::*_pm)(_LeftArg, _RightArg))
{
return obj_mem_fun1_t<_Result, _Ty, _LeftArg, _RightArg>(_pObj, _pm);
}
/*
*仿函数功能：通过指针，调用一个对象的const成员函数，并传递一个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _Arg>
class const_obj_mem_fun_t : public std::unary_function<_Arg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_Arg) const;
const_obj_mem_fun_t(const _Ty *_pObj, _MemFunPtr _pMemFunPtr)
: m_pObj(_pObj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_Arg _arg)
{
(m_pObj->*m_pMemFunPtr)(_arg);
}
private:
const _Ty *m_pObj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _Arg>
const_obj_mem_fun_t<_Result, _Ty, _Arg>
const_obj_mem_fun(const _Ty *_pObj, _Result (_Ty::*_pm)(_Arg) const)
{
return const_obj_mem_fun_t<_Result, _Ty, _Arg>(_pObj, _pm);
}
/*
*仿函数功能：通过指针，调用一个对象的const成员函数，并传递两个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
class const_obj_mem_fun1_t : public std::binary_function<_LeftArg, _RightArg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_LeftArg, _RightArg) const;
const_obj_mem_fun1_t(const _Ty *_pObj, _MemFunPtr _pMemFunPtr)
: m_pObj(_pObj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_LeftArg &_left, _RightArg &_right)
{
(m_pObj->*m_pMemFunPtr)(_left, _right);
}
private:
const _Ty *m_pObj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
const_obj_mem_fun1_t<_Result, _Ty, _LeftArg, _RightArg>
const_obj_mem_fun(const _Ty *_pObj, _Result (_Ty::*_pm)(_LeftArg, _RightArg) const)
{
return const_obj_mem_fun1_t<_Result, _Ty, _LeftArg, _RightArg>(_pObj, _pm);
}
/*
*仿函数功能：通过对象引用，调用对象的成员函数，并传递一个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _Arg>
class obj_mem_fun_ref_t : public std::unary_function<_Arg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_Arg);
obj_mem_fun_ref_t(_Ty &_obj, _MemFunPtr _pMemFunPtr)
: m_obj(_obj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_Arg _arg)
{
(m_obj.*m_pMemFunPtr)(_arg);
}
private:
_Ty &m_obj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _Arg>
obj_mem_fun_ref_t<_Result,
_Ty,
_Arg>
obj_mem_fun_ref(_Ty &_obj, _Result (_Ty::*_pm)(_Arg))
{
return obj_mem_fun_ref_t<_Result, _Ty, _Arg>(_obj, _pm);
}
/*
*仿函数功能：通过对象引用，调用对象的const成员函数，并传递一个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _Arg>
class const_obj_mem_fun_ref_t : public std::unary_function<_Arg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_Arg) const;
const_obj_mem_fun_ref_t(const _Ty &_obj, _MemFunPtr _pMemFunPtr)
: m_obj(_obj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_Arg _arg)
{
(m_obj.*m_pMemFunPtr)(_arg);
}
private:
const _Ty &m_obj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _Arg>
const_obj_mem_fun_ref_t<_Result,
_Ty,
_Arg>
const_obj_mem_fun_ref(_Ty &_obj, _Result (_Ty::*_pm)(_Arg) const)
{
return const_obj_mem_fun_ref_t<_Result, _Ty, _Arg>(_obj, _pm);
}
/*
*仿函数功能：通过对象的引用，调用对象的成员函数，并传递两个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
class obj_mem_fun1_ref_t : public std::binary_function<_LeftArg, _RightArg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_LeftArg, _RightArg);
obj_mem_fun1_ref_t(_Ty &_obj, _MemFunPtr _pMemFunPtr)
: m_obj(_obj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_LeftArg _left, _RightArg _right)
{
(m_obj.*m_pMemFunPtr)(_left, _right);
}
private:
_Ty &m_obj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
obj_mem_fun1_ref_t<_Result,
_Ty,
_LeftArg,
_RightArg>
obj_mem_fun_ref(_Ty &_obj, _Result (_Ty::*_pm)(_LeftArg, _RightArg))
{
return obj_mem_fun1_ref_t<_Result, _Ty, _LeftArg, _RightArg>(_obj, _pm);
}
/*
*仿函数功能：通过对象的引用，调用对象的const成员函数，并传递两个参数；
如果成员函数声明中该参数为引用，则传递为引用；
*/
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
class const_obj_mem_fun1_ref_t : public std::binary_function<_LeftArg, _RightArg, void>
{
public:
typedef _Result (_Ty::*_MemFunPtr)(_LeftArg, _RightArg) const;
const_obj_mem_fun1_ref_t(const _Ty &_obj, _MemFunPtr _pMemFunPtr)
: m_obj(_obj),
m_pMemFunPtr(_pMemFunPtr)
{
}
void operator ()(_LeftArg _left, _RightArg _right)
{
(m_obj.*m_pMemFunPtr)(_left, _right);
}
private:
const _Ty &m_obj;
_MemFunPtr m_pMemFunPtr;
};
template<class _Result,
class _Ty,
class _LeftArg,
class _RightArg>
const_obj_mem_fun1_ref_t<_Result,
_Ty,
_LeftArg,
_RightArg>
const_obj_mem_fun_ref(const _Ty &_obj, _Result (_Ty::*_pm)(_LeftArg, _RightArg) const)
{
return const_obj_mem_fun1_ref_t<_Result, _Ty, _LeftArg, _RightArg>(_obj, _pm);
}
}
#endif
调用示例：
定义
//这里省略组合框窗口创建过程...
CComboBox m_combo;
CString arString[] = {
_T("1"),
_T("2"),
_T("3"),
_T("4"),
_T("5"),
_T("6")
};
int nCount = sizeof(arString) / sizeof(CString);
1、
auto combo1 = function_lib::obj_mem_fun(&m_combo, &CComboBox::AddString); std::for_each(arString, arString + nCount, combo1); m_combo.ResetContent();
2、
auto combo2 = function_lib::bind1st(function_lib::obj_mem_fun(&m_combo, &CComboBox::InsertString), -1); std::for_each(arString, arString + nCount, combo2);
3、
auto func = function_lib::const_obj_mem_fun1_t<void, CComboBox, int, CString&>(&m_combo, &CComboBox::GetLBText); auto combo3 = function_lib::const_bind1st(func, 0); std::for_each(arString, arString + nCount, combo3); //失败，无法将CString转化为LPTSTR //auto func = function_lib::const_obj_mem_fun1_t<int, CComboBox, int, LPTSTR >(&m_combo, &CComboBox::GetLBText); //auto combo3 = function_lib::const_bind1st(func, 0); //std::for_each(arString, arString + nCount, combo3);
4、
m_combo.ResetContent(); auto combo4 = function_lib::obj_mem_fun_ref(m_combo, &CComboBox::AddString); std::for_each(arString, arString + nCount, combo4);
5、
m_combo.ResetContent(); auto combo5 = function_lib::bind1st(function_lib::obj_mem_fun_ref(m_combo, &CComboBox::InsertString), 0); std::for_each(arString, arString + nCount, combo5);
6、
auto func6 = function_lib::const_obj_mem_fun1_ref_t<void, CComboBox, int, CString&>(m_combo, &CComboBox::GetLBText); auto combo6 = function_lib::const_bind1st(func6, 0); std::for_each(arString, arString+ nCount, combo6);
浙公网安备 33010602011771号