20，STL仿函数需要定义相应的型别，以便让配接器取出，以此而拥有配接能力，相应型别只是一些typedef，所有操作在编译期全部完成，对程序的执行效率没有影响。仿函数的相应型别主要用来表现函数参数型别和传回值，为了方便，STL已经定义了两个class，代码如下：
template <class Arg, class Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; }; template </class><class Arg1, class Arg2, class Result> struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; }; </class> |
21，仿函数只是行为类似函数的对象，自定义了operator()操作符。以下为几个仿函数的代码：
template <class T> struct logical_not : public unary_function<T, bool> { bool operator()(const T& x) const { return !x; } }; template <class T> struct plus : public binary_function<T, T, T> { T operator()(const T& x, const T& y) const { return x + y; } }; |
22，每一个fuction adapters内也有一个member object，其型别等同于它要配接的对象，以下为几个函数配接器的源码：
template <class Operation> class binder1st : public unary_function<typename Operation::second_argument_type, typename Operation::result_type> { protected: Operation op; typename Operation::first_argument_type value; public: binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y) {} typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const { return op(value, x); } }; template <class Operation, class T> inline binder1st<Operation> bind1st(const Operation& op, const T& x) { typedef typename Operation::first_argument_type arg1_type; return binder1st<Operation>(op, arg1_type(x)); } //-------------------------------------- template <class Arg, class Result> class pointer_to_unary_function : public unary_function<Arg, Result> { protected: Result (*ptr)(Arg); public: pointer_to_unary_function() {} explicit pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {} Result operator()(Arg x) const { return ptr(x); } }; template <class Arg, class Result> inline pointer_to_unary_function<Arg, Result> ptr_fun(Result (*x)(Arg)) { return pointer_to_unary_function<Arg, Result>(x); } template <class Arg1, class Arg2, class Result> class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> { protected: Result (*ptr)(Arg1, Arg2); public: pointer_to_binary_function() {} explicit pointer_to_binary_function(Result (*x)(Arg1, Arg2)) : ptr(x) {} Result operator()(Arg1 x, Arg2 y) const { return ptr(x, y); } }; template <class Arg1, class Arg2, class Result> inline pointer_to_binary_function<Arg1, Arg2, Result> ptr_fun(Result (*x)(Arg1, Arg2)) { return pointer_to_binary_function<Arg1, Arg2, Result>(x); } |
23，一个使用mem_fun的示例代码：
class Shape { public: virtual void draw() = 0; }; class Circle : public Shape { public: virtual void draw() { cout << "Circle::Draw()" << endl; } }; class Square : public Shape { public: virtual void draw() { cout << "Square::Draw()" << endl; } }; int main() { vector<Shape*> vs; vs.push_back(new Circle); vs.push_back(new Square); for_each(vs.begin(), vs.end(), mem_fun(&Shape::draw)); } |