//---------------------------15/04/01----------------------------
//仿函数是为了算法而诞生的，可以作为算法的一个参数，来自定义各种操作，比如比大小，返回bool值，对元素进行操作等
//虽然这些函数也能实现，但是如果配合配接器(adapter)可以产生更灵活的变化。
//为了使对象像函数一样，就必须重载operator()
//unary_function
template<class Arg, class Result>
struct unary_function
{
//参数类型
typedef Arg argument_type;
//返回值类型
typedef Result result_type;
};
//binary_functione
//二元仿函数
template<class Arg1, class Arg2, class Result>
struct binary_functione
{
typedef Arg1 first_argument_type;
typedef arg2 second_argument_type;
typedef Result result_type;
};
//算术类仿函数
template<class T>
struct plus : public binary_functione<T, T, T>
{
T operator()(const T& x, const T& y) const
{
return x + y;
}
};
template<class T>
struct minus : public binary_functione<T, T, T>
{
T operator()(const T& x, const T& y) const
{
return x - y;
}
};
template<class T>
struct multiplies : public binary_functione<T, T, T>
{
T operator()(const T& x, const T& y) const
{
return x * y;
}
};
template<class T>
struct divides : public binary_functione<T, T, T>
{
T operator()(const T& x, const T& y) const
{
return x / y;
}
};
template<class T>
struct modulus : public binary_functione<T, T, T>
{
T operator()(const T& x, const T& y) const
{
return x & y;
}
};
template<class T>
struct negate: public unary_function<T, T>
{
T operator()(const T& x) const
{
return -x;
}
};
//证同元素，数值a与该元素做op操作会得到自己。 加法的证同元素为0 乘法为1
template<class T>
inline T identity_element(plus<T>)
{
return T(0);
};
template<class T>
inline T identity_element(multiplies<T>)
{
return T(1);
};
//关系运算类仿函数
template<class T>
struct equal_to : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x == y;
}
};
template<class T>
struct not_equal_to : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x != y;
}
};
template<class T>
struct greater : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x > y;
}
};
template<class T>
struct less : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
template<class T>
struct greater_equal : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x >= y;
}
};
template<class T>
struct less_equal : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x <= y;
}
};
//逻辑类仿函数
template<class T>
struct logical_and : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x && y;
}
};
template<class T>
struct logical_or : public binary_functione<T, T, bool>
{
bool operator()(const T& x, const T& y) const
{
return x || y;
}
};
template<class T>
struct logical_not : public unary_function<T, bool>
{
bool operator()(const T& x) const
{
return !x;
}
};
//证同函数，任何数通过此函数调用运算后返回原值。
template<class T>
struct identity : public unary_function<T, T>
{
const T& operator()(const T& x) const
{
return x;
}
};
//选择函数 接受pair，传回第一个元素
template<class Pair>
struct select1st : public unary_function<Pair, typename Pair::first_type>
{
const typename Pair::first_type& operator()(const Pair& x) const
{
return x.first;
}
};
template<class Pair>
struct select2nd : public unary_function<Pair, typename Pair::second_type>
{
const typename Pair::second_type& operator()(const Pair& x) const
{
return x.second;
}
};
//投射函数：传回第一参数，忽略第二参数
template<class Arg1, class Arg2>
struct project1st : public binary_functione<Arg1, Arg2, Arg1>
{
Arg1 operator()(const Arg1& x, const Arg2& y) const
{
return x;
}
}
template<class Arg1, class Arg2>
struct project2nd : public binary_functione<Arg1, Arg2, Arg2>
{
Arg2 operator()(const Arg1& x, const Arg2& y) const
{
return y;
}
}
原文地址：http://blog.csdn.net/boydfd/article/details/44808871
