stl_func.h
上传用户:nizebo
上传日期:2022-05-14
资源大小:882k
文件大小:22k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1996-1998
  16.  * Silicon Graphics Computer Systems, Inc.
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Silicon Graphics makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  */
  26. /* NOTE: This is an internal header file, included by other STL headers.
  27.  *   You should not attempt to use it directly.
  28.  */
  29. #ifndef __SGI_STL_INTERNAL_FUNCTION_H
  30. #define __SGI_STL_INTERNAL_FUNCTION_H
  31. __STL_BEGIN_NAMESPACE
  32. template <class _Arg, class _Result>
  33. struct unary_function {
  34.   typedef _Arg argument_type;
  35.   typedef _Result result_type;
  36. };
  37. template <class _Arg1, class _Arg2, class _Result>
  38. struct binary_function {
  39.   typedef _Arg1 first_argument_type;
  40.   typedef _Arg2 second_argument_type;
  41.   typedef _Result result_type;
  42. };      
  43. template <class _Tp>
  44. struct plus : public binary_function<_Tp,_Tp,_Tp> {
  45.   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
  46. };
  47. template <class _Tp>
  48. struct minus : public binary_function<_Tp,_Tp,_Tp> {
  49.   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
  50. };
  51. template <class _Tp>
  52. struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
  53.   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
  54. };
  55. template <class _Tp>
  56. struct divides : public binary_function<_Tp,_Tp,_Tp> {
  57.   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
  58. };
  59. // identity_element (not part of the C++ standard).
  60. template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
  61.   return _Tp(0);
  62. }
  63. template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
  64.   return _Tp(1);
  65. }
  66. template <class _Tp>
  67. struct modulus : public binary_function<_Tp,_Tp,_Tp> 
  68. {
  69.   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
  70. };
  71. template <class _Tp>
  72. struct negate : public unary_function<_Tp,_Tp> 
  73. {
  74.   _Tp operator()(const _Tp& __x) const { return -__x; }
  75. };
  76. template <class _Tp>
  77. struct equal_to : public binary_function<_Tp,_Tp,bool> 
  78. {
  79.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
  80. };
  81. template <class _Tp>
  82. struct not_equal_to : public binary_function<_Tp,_Tp,bool> 
  83. {
  84.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
  85. };
  86. template <class _Tp>
  87. struct greater : public binary_function<_Tp,_Tp,bool> 
  88. {
  89.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
  90. };
  91. template <class _Tp>
  92. struct less : public binary_function<_Tp,_Tp,bool> 
  93. {
  94.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
  95. };
  96. template <class _Tp>
  97. struct greater_equal : public binary_function<_Tp,_Tp,bool>
  98. {
  99.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
  100. };
  101. template <class _Tp>
  102. struct less_equal : public binary_function<_Tp,_Tp,bool> 
  103. {
  104.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
  105. };
  106. template <class _Tp>
  107. struct logical_and : public binary_function<_Tp,_Tp,bool>
  108. {
  109.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
  110. };
  111. template <class _Tp>
  112. struct logical_or : public binary_function<_Tp,_Tp,bool>
  113. {
  114.   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
  115. };
  116. template <class _Tp>
  117. struct logical_not : public unary_function<_Tp,bool>
  118. {
  119.   bool operator()(const _Tp& __x) const { return !__x; }
  120. };
  121. template <class _Predicate>
  122. class unary_negate
  123.   : public unary_function<typename _Predicate::argument_type, bool> {
  124. protected:
  125.   _Predicate _M_pred;
  126. public:
  127.   explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
  128.   bool operator()(const typename _Predicate::argument_type& __x) const {
  129.     return !_M_pred(__x);
  130.   }
  131. };
  132. template <class _Predicate>
  133. inline unary_negate<_Predicate> 
  134. not1(const _Predicate& __pred)
  135. {
  136.   return unary_negate<_Predicate>(__pred);
  137. }
  138. template <class _Predicate> 
  139. class binary_negate 
  140.   : public binary_function<typename _Predicate::first_argument_type,
  141.                            typename _Predicate::second_argument_type,
  142.                            bool> {
  143. protected:
  144.   _Predicate _M_pred;
  145. public:
  146.   explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
  147.   bool operator()(const typename _Predicate::first_argument_type& __x, 
  148.                   const typename _Predicate::second_argument_type& __y) const
  149.   {
  150.     return !_M_pred(__x, __y); 
  151.   }
  152. };
  153. template <class _Predicate>
  154. inline binary_negate<_Predicate> 
  155. not2(const _Predicate& __pred)
  156. {
  157.   return binary_negate<_Predicate>(__pred);
  158. }
  159. template <class _Operation> 
  160. class binder1st
  161.   : public unary_function<typename _Operation::second_argument_type,
  162.                           typename _Operation::result_type> {
  163. protected:
  164.   _Operation op;
  165.   typename _Operation::first_argument_type value;
  166. public:
  167.   binder1st(const _Operation& __x,
  168.             const typename _Operation::first_argument_type& __y)
  169.       : op(__x), value(__y) {}
  170.   typename _Operation::result_type
  171.   operator()(const typename _Operation::second_argument_type& __x) const {
  172.     return op(value, __x); 
  173.   }
  174. };
  175. template <class _Operation, class _Tp>
  176. inline binder1st<_Operation> 
  177. bind1st(const _Operation& __fn, const _Tp& __x) 
  178. {
  179.   typedef typename _Operation::first_argument_type _Arg1_type;
  180.   return binder1st<_Operation>(__fn, _Arg1_type(__x));
  181. }
  182. template <class _Operation> 
  183. class binder2nd
  184.   : public unary_function<typename _Operation::first_argument_type,
  185.                           typename _Operation::result_type> {
  186. protected:
  187.   _Operation op;
  188.   typename _Operation::second_argument_type value;
  189. public:
  190.   binder2nd(const _Operation& __x,
  191.             const typename _Operation::second_argument_type& __y) 
  192.       : op(__x), value(__y) {}
  193.   typename _Operation::result_type
  194.   operator()(const typename _Operation::first_argument_type& __x) const {
  195.     return op(__x, value); 
  196.   }
  197. };
  198. template <class _Operation, class _Tp>
  199. inline binder2nd<_Operation> 
  200. bind2nd(const _Operation& __fn, const _Tp& __x) 
  201. {
  202.   typedef typename _Operation::second_argument_type _Arg2_type;
  203.   return binder2nd<_Operation>(__fn, _Arg2_type(__x));
  204. }
  205. // unary_compose and binary_compose (extensions, not part of the standard).
  206. template <class _Operation1, class _Operation2>
  207. class unary_compose
  208.   : public unary_function<typename _Operation2::argument_type,
  209.                           typename _Operation1::result_type> 
  210. {
  211. protected:
  212.   _Operation1 _M_fn1;
  213.   _Operation2 _M_fn2;
  214. public:
  215.   unary_compose(const _Operation1& __x, const _Operation2& __y) 
  216.     : _M_fn1(__x), _M_fn2(__y) {}
  217.   typename _Operation1::result_type
  218.   operator()(const typename _Operation2::argument_type& __x) const {
  219.     return _M_fn1(_M_fn2(__x));
  220.   }
  221. };
  222. template <class _Operation1, class _Operation2>
  223. inline unary_compose<_Operation1,_Operation2> 
  224. compose1(const _Operation1& __fn1, const _Operation2& __fn2)
  225. {
  226.   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
  227. }
  228. template <class _Operation1, class _Operation2, class _Operation3>
  229. class binary_compose
  230.   : public unary_function<typename _Operation2::argument_type,
  231.                           typename _Operation1::result_type> {
  232. protected:
  233.   _Operation1 _M_fn1;
  234.   _Operation2 _M_fn2;
  235.   _Operation3 _M_fn3;
  236. public:
  237.   binary_compose(const _Operation1& __x, const _Operation2& __y, 
  238.                  const _Operation3& __z) 
  239.     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
  240.   typename _Operation1::result_type
  241.   operator()(const typename _Operation2::argument_type& __x) const {
  242.     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
  243.   }
  244. };
  245. template <class _Operation1, class _Operation2, class _Operation3>
  246. inline binary_compose<_Operation1, _Operation2, _Operation3> 
  247. compose2(const _Operation1& __fn1, const _Operation2& __fn2, 
  248.          const _Operation3& __fn3)
  249. {
  250.   return binary_compose<_Operation1,_Operation2,_Operation3>
  251.     (__fn1, __fn2, __fn3);
  252. }
  253. template <class _Arg, class _Result>
  254. class pointer_to_unary_function : public unary_function<_Arg, _Result> {
  255. protected:
  256.   _Result (*_M_ptr)(_Arg);
  257. public:
  258.   pointer_to_unary_function() {}
  259.   explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
  260.   _Result operator()(_Arg __x) const { return _M_ptr(__x); }
  261. };
  262. template <class _Arg, class _Result>
  263. inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
  264. {
  265.   return pointer_to_unary_function<_Arg, _Result>(__x);
  266. }
  267. template <class _Arg1, class _Arg2, class _Result>
  268. class pointer_to_binary_function : 
  269.   public binary_function<_Arg1,_Arg2,_Result> {
  270. protected:
  271.     _Result (*_M_ptr)(_Arg1, _Arg2);
  272. public:
  273.     pointer_to_binary_function() {}
  274.     explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 
  275.       : _M_ptr(__x) {}
  276.     _Result operator()(_Arg1 __x, _Arg2 __y) const {
  277.       return _M_ptr(__x, __y);
  278.     }
  279. };
  280. template <class _Arg1, class _Arg2, class _Result>
  281. inline pointer_to_binary_function<_Arg1,_Arg2,_Result> 
  282. ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
  283.   return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
  284. }
  285. // identity is an extensions: it is not part of the standard.
  286. template <class _Tp>
  287. struct _Identity : public unary_function<_Tp,_Tp> {
  288.   const _Tp& operator()(const _Tp& __x) const { return __x; }
  289. };
  290. template <class _Tp> struct identity : public _Identity<_Tp> {};
  291. // select1st and select2nd are extensions: they are not part of the standard.
  292. template <class _Pair>
  293. struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
  294.   const typename _Pair::first_type& operator()(const _Pair& __x) const {
  295.     return __x.first;
  296.   }
  297. };
  298. template <class _Pair>
  299. struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
  300. {
  301.   const typename _Pair::second_type& operator()(const _Pair& __x) const {
  302.     return __x.second;
  303.   }
  304. };
  305. template <class _Pair> struct select1st : public _Select1st<_Pair> {};
  306. template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};
  307. // project1st and project2nd are extensions: they are not part of the standard
  308. template <class _Arg1, class _Arg2>
  309. struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
  310.   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
  311. };
  312. template <class _Arg1, class _Arg2>
  313. struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
  314.   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
  315. };
  316. template <class _Arg1, class _Arg2> 
  317. struct project1st : public _Project1st<_Arg1, _Arg2> {};
  318. template <class _Arg1, class _Arg2>
  319. struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
  320. // constant_void_fun, constant_unary_fun, and constant_binary_fun are
  321. // extensions: they are not part of the standard.  (The same, of course,
  322. // is true of the helper functions constant0, constant1, and constant2.)
  323. template <class _Result>
  324. struct _Constant_void_fun {
  325.   typedef _Result result_type;
  326.   result_type _M_val;
  327.   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
  328.   const result_type& operator()() const { return _M_val; }
  329. };  
  330. template <class _Result, class _Argument>
  331. struct _Constant_unary_fun {
  332.   typedef _Argument argument_type;
  333.   typedef  _Result  result_type;
  334.   result_type _M_val;
  335.   _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
  336.   const result_type& operator()(const _Argument&) const { return _M_val; }
  337. };
  338. template <class _Result, class _Arg1, class _Arg2>
  339. struct _Constant_binary_fun {
  340.   typedef  _Arg1   first_argument_type;
  341.   typedef  _Arg2   second_argument_type;
  342.   typedef  _Result result_type;
  343.   _Result _M_val;
  344.   _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
  345.   const result_type& operator()(const _Arg1&, const _Arg2&) const {
  346.     return _M_val;
  347.   }
  348. };
  349. template <class _Result>
  350. struct constant_void_fun : public _Constant_void_fun<_Result> {
  351.   constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
  352. };  
  353. template <class _Result,
  354.           class _Argument __STL_DEPENDENT_DEFAULT_TMPL(_Result)>
  355. struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
  356. {
  357.   constant_unary_fun(const _Result& __v)
  358.     : _Constant_unary_fun<_Result, _Argument>(__v) {}
  359. };
  360. template <class _Result,
  361.           class _Arg1 __STL_DEPENDENT_DEFAULT_TMPL(_Result),
  362.           class _Arg2 __STL_DEPENDENT_DEFAULT_TMPL(_Arg1)>
  363. struct constant_binary_fun
  364.   : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
  365. {
  366.   constant_binary_fun(const _Result& __v)
  367.     : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
  368. };
  369. template <class _Result>
  370. inline constant_void_fun<_Result> constant0(const _Result& __val)
  371. {
  372.   return constant_void_fun<_Result>(__val);
  373. }
  374. template <class _Result>
  375. inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
  376. {
  377.   return constant_unary_fun<_Result,_Result>(__val);
  378. }
  379. template <class _Result>
  380. inline constant_binary_fun<_Result,_Result,_Result> 
  381. constant2(const _Result& __val)
  382. {
  383.   return constant_binary_fun<_Result,_Result,_Result>(__val);
  384. }
  385. // subtractive_rng is an extension: it is not part of the standard.
  386. // Note: this code assumes that int is 32 bits.
  387. class subtractive_rng : public unary_function<unsigned int, unsigned int> {
  388. private:
  389.   unsigned int _M_table[55];
  390.   size_t _M_index1;
  391.   size_t _M_index2;
  392. public:
  393.   unsigned int operator()(unsigned int __limit) {
  394.     _M_index1 = (_M_index1 + 1) % 55;
  395.     _M_index2 = (_M_index2 + 1) % 55;
  396.     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
  397.     return _M_table[_M_index1] % __limit;
  398.   }
  399.   void _M_initialize(unsigned int __seed)
  400.   {
  401.     unsigned int __k = 1;
  402.     _M_table[54] = __seed;
  403.     size_t __i;
  404.     for (__i = 0; __i < 54; __i++) {
  405.         size_t __ii = (21 * (__i + 1) % 55) - 1;
  406.         _M_table[__ii] = __k;
  407.         __k = __seed - __k;
  408.         __seed = _M_table[__ii];
  409.     }
  410.     for (int __loop = 0; __loop < 4; __loop++) {
  411.         for (__i = 0; __i < 55; __i++)
  412.             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
  413.     }
  414.     _M_index1 = 0;
  415.     _M_index2 = 31;
  416.   }
  417.   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
  418.   subtractive_rng() { _M_initialize(161803398u); }
  419. };
  420. // Adaptor function objects: pointers to member functions.
  421. // There are a total of 16 = 2^4 function objects in this family.
  422. //  (1) Member functions taking no arguments vs member functions taking
  423. //       one argument.
  424. //  (2) Call through pointer vs call through reference.
  425. //  (3) Member function with void return type vs member function with
  426. //      non-void return type.
  427. //  (4) Const vs non-const member function.
  428. // Note that choice (3) is nothing more than a workaround: according
  429. //  to the draft, compilers should handle void and non-void the same way.
  430. //  This feature is not yet widely implemented, though.  You can only use
  431. //  member functions returning void if your compiler supports partial
  432. //  specialization.
  433. // All of this complexity is in the function objects themselves.  You can
  434. //  ignore it by using the helper function mem_fun and mem_fun_ref,
  435. //  which create whichever type of adaptor is appropriate.
  436. //  (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
  437. //  but they are provided for backward compatibility.)
  438. template <class _Ret, class _Tp>
  439. class mem_fun_t : public unary_function<_Tp*,_Ret> {
  440. public:
  441.   explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  442.   _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
  443. private:
  444.   _Ret (_Tp::*_M_f)();
  445. };
  446. template <class _Ret, class _Tp>
  447. class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
  448. public:
  449.   explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  450.   _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
  451. private:
  452.   _Ret (_Tp::*_M_f)() const;
  453. };
  454. template <class _Ret, class _Tp>
  455. class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
  456. public:
  457.   explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  458.   _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
  459. private:
  460.   _Ret (_Tp::*_M_f)();
  461. };
  462. template <class _Ret, class _Tp>
  463. class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
  464. public:
  465.   explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  466.   _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
  467. private:
  468.   _Ret (_Tp::*_M_f)() const;
  469. };
  470. template <class _Ret, class _Tp, class _Arg>
  471. class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
  472. public:
  473.   explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  474.   _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
  475. private:
  476.   _Ret (_Tp::*_M_f)(_Arg);
  477. };
  478. template <class _Ret, class _Tp, class _Arg>
  479. class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
  480. public:
  481.   explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  482.   _Ret operator()(const _Tp* __p, _Arg __x) const
  483.     { return (__p->*_M_f)(__x); }
  484. private:
  485.   _Ret (_Tp::*_M_f)(_Arg) const;
  486. };
  487. template <class _Ret, class _Tp, class _Arg>
  488. class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
  489. public:
  490.   explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  491.   _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
  492. private:
  493.   _Ret (_Tp::*_M_f)(_Arg);
  494. };
  495. template <class _Ret, class _Tp, class _Arg>
  496. class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
  497. public:
  498.   explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  499.   _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
  500. private:
  501.   _Ret (_Tp::*_M_f)(_Arg) const;
  502. };
  503. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  504. template <class _Tp>
  505. class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
  506. public:
  507.   explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  508.   void operator()(_Tp* __p) const { (__p->*_M_f)(); }
  509. private:
  510.   void (_Tp::*_M_f)();
  511. };
  512. template <class _Tp>
  513. class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
  514. public:
  515.   explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  516.   void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
  517. private:
  518.   void (_Tp::*_M_f)() const;
  519. };
  520. template <class _Tp>
  521. class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
  522. public:
  523.   explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  524.   void operator()(_Tp& __r) const { (__r.*_M_f)(); }
  525. private:
  526.   void (_Tp::*_M_f)();
  527. };
  528. template <class _Tp>
  529. class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
  530. public:
  531.   explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  532.   void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
  533. private:
  534.   void (_Tp::*_M_f)() const;
  535. };
  536. template <class _Tp, class _Arg>
  537. class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
  538. public:
  539.   explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  540.   void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
  541. private:
  542.   void (_Tp::*_M_f)(_Arg);
  543. };
  544. template <class _Tp, class _Arg>
  545. class const_mem_fun1_t<void, _Tp, _Arg> 
  546.   : public binary_function<const _Tp*,_Arg,void> {
  547. public:
  548.   explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  549.   void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
  550. private:
  551.   void (_Tp::*_M_f)(_Arg) const;
  552. };
  553. template <class _Tp, class _Arg>
  554. class mem_fun1_ref_t<void, _Tp, _Arg>
  555.   : public binary_function<_Tp,_Arg,void> {
  556. public:
  557.   explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  558.   void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
  559. private:
  560.   void (_Tp::*_M_f)(_Arg);
  561. };
  562. template <class _Tp, class _Arg>
  563. class const_mem_fun1_ref_t<void, _Tp, _Arg>
  564.   : public binary_function<_Tp,_Arg,void> {
  565. public:
  566.   explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  567.   void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
  568. private:
  569.   void (_Tp::*_M_f)(_Arg) const;
  570. };
  571. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  572. // Mem_fun adaptor helper functions.  There are only two:
  573. //  mem_fun and mem_fun_ref.  (mem_fun1 and mem_fun1_ref 
  574. //  are provided for backward compatibility, but they are no longer
  575. //  part of the C++ standard.)
  576. template <class _Ret, class _Tp>
  577. inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
  578.   { return mem_fun_t<_Ret,_Tp>(__f); }
  579. template <class _Ret, class _Tp>
  580. inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
  581.   { return const_mem_fun_t<_Ret,_Tp>(__f); }
  582. template <class _Ret, class _Tp>
  583. inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)()) 
  584.   { return mem_fun_ref_t<_Ret,_Tp>(__f); }
  585. template <class _Ret, class _Tp>
  586. inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
  587.   { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
  588. template <class _Ret, class _Tp, class _Arg>
  589. inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
  590.   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  591. template <class _Ret, class _Tp, class _Arg>
  592. inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  593.   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  594. template <class _Ret, class _Tp, class _Arg>
  595. inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  596.   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  597. template <class _Ret, class _Tp, class _Arg>
  598. inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
  599. mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  600.   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  601. template <class _Ret, class _Tp, class _Arg>
  602. inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  603.   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  604. template <class _Ret, class _Tp, class _Arg>
  605. inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  606.   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  607. template <class _Ret, class _Tp, class _Arg>
  608. inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  609.   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  610. template <class _Ret, class _Tp, class _Arg>
  611. inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
  612. mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  613.   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  614. __STL_END_NAMESPACE
  615. #endif /* __SGI_STL_INTERNAL_FUNCTION_H */
  616. // Local Variables:
  617. // mode:C++
  618. // End: