stl_function.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:18k
源码类别:

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
  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 T>
  44. struct plus : public binary_function<T, T, T> {
  45.     T operator()(const T& x, const T& y) const { return x + y; }
  46. };
  47. template <class T>
  48. struct minus : public binary_function<T, T, T> {
  49.     T operator()(const T& x, const T& y) const { return x - y; }
  50. };
  51. template <class T>
  52. struct multiplies : public binary_function<T, T, T> {
  53.     T operator()(const T& x, const T& y) const { return x * y; }
  54. };
  55. template <class T>
  56. struct divides : public binary_function<T, T, T> {
  57.     T operator()(const T& x, const T& y) const { return x / y; }
  58. };
  59. template <class T> inline T identity_element(plus<T>) { return T(0); }
  60. template <class T> inline T identity_element(multiplies<T>) { return T(1); }
  61. template <class T>
  62. struct modulus : public binary_function<T, T, T> {
  63.     T operator()(const T& x, const T& y) const { return x % y; }
  64. };
  65. template <class T>
  66. struct negate : public unary_function<T, T> {
  67.     T operator()(const T& x) const { return -x; }
  68. };
  69. template <class T>
  70. struct equal_to : public binary_function<T, T, bool> {
  71.     bool operator()(const T& x, const T& y) const { return x == y; }
  72. };
  73. template <class T>
  74. struct not_equal_to : public binary_function<T, T, bool> {
  75.     bool operator()(const T& x, const T& y) const { return x != y; }
  76. };
  77. template <class T>
  78. struct greater : public binary_function<T, T, bool> {
  79.     bool operator()(const T& x, const T& y) const { return x > y; }
  80. };
  81. template <class T>
  82. struct less : public binary_function<T, T, bool> {
  83.     bool operator()(const T& x, const T& y) const { return x < y; }
  84. };
  85. template <class T>
  86. struct greater_equal : public binary_function<T, T, bool> {
  87.     bool operator()(const T& x, const T& y) const { return x >= y; }
  88. };
  89. template <class T>
  90. struct less_equal : public binary_function<T, T, bool> {
  91.     bool operator()(const T& x, const T& y) const { return x <= y; }
  92. };
  93. template <class T>
  94. struct logical_and : public binary_function<T, T, bool> {
  95.     bool operator()(const T& x, const T& y) const { return x && y; }
  96. };
  97. template <class T>
  98. struct logical_or : public binary_function<T, T, bool> {
  99.     bool operator()(const T& x, const T& y) const { return x || y; }
  100. };
  101. template <class T>
  102. struct logical_not : public unary_function<T, bool> {
  103.     bool operator()(const T& x) const { return !x; }
  104. };
  105. template <class Predicate>
  106. class unary_negate
  107.   : public unary_function<typename Predicate::argument_type, bool> {
  108. protected:
  109.   Predicate pred;
  110. public:
  111.   explicit unary_negate(const Predicate& x) : pred(x) {}
  112.   bool operator()(const typename Predicate::argument_type& x) const {
  113.     return !pred(x);
  114.   }
  115. };
  116. template <class Predicate>
  117. inline unary_negate<Predicate> not1(const Predicate& pred) {
  118.   return unary_negate<Predicate>(pred);
  119. }
  120. template <class Predicate> 
  121. class binary_negate 
  122.   : public binary_function<typename Predicate::first_argument_type,
  123.                            typename Predicate::second_argument_type,
  124.                            bool> {
  125. protected:
  126.   Predicate pred;
  127. public:
  128.   explicit binary_negate(const Predicate& x) : pred(x) {}
  129.   bool operator()(const typename Predicate::first_argument_type& x, 
  130.                   const typename Predicate::second_argument_type& y) const {
  131.     return !pred(x, y); 
  132.   }
  133. };
  134. template <class Predicate>
  135. inline binary_negate<Predicate> not2(const Predicate& pred) {
  136.   return binary_negate<Predicate>(pred);
  137. }
  138. template <class Operation> 
  139. class binder1st
  140.   : public unary_function<typename Operation::second_argument_type,
  141.                           typename Operation::result_type> {
  142. protected:
  143.   Operation op;
  144.   typename Operation::first_argument_type value;
  145. public:
  146.   binder1st(const Operation& x,
  147.             const typename Operation::first_argument_type& y)
  148.       : op(x), value(y) {}
  149.   typename Operation::result_type
  150.   operator()(const typename Operation::second_argument_type& x) const {
  151.     return op(value, x); 
  152.   }
  153. };
  154. template <class Operation, class T>
  155. inline binder1st<Operation> bind1st(const Operation& op, const T& x) {
  156.   typedef typename Operation::first_argument_type arg1_type;
  157.   return binder1st<Operation>(op, arg1_type(x));
  158. }
  159. template <class Operation> 
  160. class binder2nd
  161.   : public unary_function<typename Operation::first_argument_type,
  162.                           typename Operation::result_type> {
  163. protected:
  164.   Operation op;
  165.   typename Operation::second_argument_type value;
  166. public:
  167.   binder2nd(const Operation& x,
  168.             const typename Operation::second_argument_type& y) 
  169.       : op(x), value(y) {}
  170.   typename Operation::result_type
  171.   operator()(const typename Operation::first_argument_type& x) const {
  172.     return op(x, value); 
  173.   }
  174. };
  175. template <class Operation, class T>
  176. inline binder2nd<Operation> bind2nd(const Operation& op, const T& x) {
  177.   typedef typename Operation::second_argument_type arg2_type;
  178.   return binder2nd<Operation>(op, arg2_type(x));
  179. }
  180. template <class Operation1, class Operation2>
  181. class unary_compose : public unary_function<typename Operation2::argument_type,
  182.                                             typename Operation1::result_type> {
  183. protected:
  184.   Operation1 op1;
  185.   Operation2 op2;
  186. public:
  187.   unary_compose(const Operation1& x, const Operation2& y) : op1(x), op2(y) {}
  188.   typename Operation1::result_type
  189.   operator()(const typename Operation2::argument_type& x) const {
  190.     return op1(op2(x));
  191.   }
  192. };
  193. template <class Operation1, class Operation2>
  194. inline unary_compose<Operation1, Operation2> compose1(const Operation1& op1, 
  195.                                                       const Operation2& op2) {
  196.   return unary_compose<Operation1, Operation2>(op1, op2);
  197. }
  198. template <class Operation1, class Operation2, class Operation3>
  199. class binary_compose
  200.   : public unary_function<typename Operation2::argument_type,
  201.                           typename Operation1::result_type> {
  202. protected:
  203.   Operation1 op1;
  204.   Operation2 op2;
  205.   Operation3 op3;
  206. public:
  207.   binary_compose(const Operation1& x, const Operation2& y, 
  208.                  const Operation3& z) : op1(x), op2(y), op3(z) { }
  209.   typename Operation1::result_type
  210.   operator()(const typename Operation2::argument_type& x) const {
  211.     return op1(op2(x), op3(x));
  212.   }
  213. };
  214. template <class Operation1, class Operation2, class Operation3>
  215. inline binary_compose<Operation1, Operation2, Operation3> 
  216. compose2(const Operation1& op1, const Operation2& op2, const Operation3& op3) {
  217.   return binary_compose<Operation1, Operation2, Operation3>(op1, op2, op3);
  218. }
  219. template <class Arg, class Result>
  220. class pointer_to_unary_function : public unary_function<Arg, Result> {
  221. protected:
  222.   Result (*ptr)(Arg);
  223. public:
  224.   pointer_to_unary_function() {}
  225.   explicit pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {}
  226.   Result operator()(Arg x) const { return ptr(x); }
  227. };
  228. template <class Arg, class Result>
  229. inline pointer_to_unary_function<Arg, Result> ptr_fun(Result (*x)(Arg)) {
  230.   return pointer_to_unary_function<Arg, Result>(x);
  231. }
  232. template <class Arg1, class Arg2, class Result>
  233. class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> {
  234. protected:
  235.     Result (*ptr)(Arg1, Arg2);
  236. public:
  237.     pointer_to_binary_function() {}
  238.     explicit pointer_to_binary_function(Result (*x)(Arg1, Arg2)) : ptr(x) {}
  239.     Result operator()(Arg1 x, Arg2 y) const { return ptr(x, y); }
  240. };
  241. template <class Arg1, class Arg2, class Result>
  242. inline pointer_to_binary_function<Arg1, Arg2, Result> 
  243. ptr_fun(Result (*x)(Arg1, Arg2)) {
  244.   return pointer_to_binary_function<Arg1, Arg2, Result>(x);
  245. }
  246. template <class T>
  247. struct identity : public unary_function<T, T> {
  248.   const T& operator()(const T& x) const { return x; }
  249. };
  250. template <class Pair>
  251. struct select1st : public unary_function<Pair, typename Pair::first_type> {
  252.   const typename Pair::first_type& operator()(const Pair& x) const
  253.   {
  254.     return x.first;
  255.   }
  256. };
  257. template <class Pair>
  258. struct select2nd : public unary_function<Pair, typename Pair::second_type> {
  259.   const typename Pair::second_type& operator()(const Pair& x) const
  260.   {
  261.     return x.second;
  262.   }
  263. };
  264. template <class Arg1, class Arg2>
  265. struct project1st : public binary_function<Arg1, Arg2, Arg1> {
  266.   Arg1 operator()(const Arg1& x, const Arg2&) const { return x; }
  267. };
  268. template <class Arg1, class Arg2>
  269. struct project2nd : public binary_function<Arg1, Arg2, Arg2> {
  270.   Arg2 operator()(const Arg1&, const Arg2& y) const { return y; }
  271. };
  272. template <class Result>
  273. struct constant_void_fun
  274. {
  275.   typedef Result result_type;
  276.   result_type val;
  277.   constant_void_fun(const result_type& v) : val(v) {}
  278.   const result_type& operator()() const { return val; }
  279. };  
  280. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  281. template <class Result, class Argument = Result>
  282. #else
  283. template <class Result, class Argument>
  284. #endif
  285. struct constant_unary_fun : public unary_function<Argument, Result> {
  286.   Result val;
  287.   constant_unary_fun(const Result& v) : val(v) {}
  288.   const Result& operator()(const Argument&) const { return val; }
  289. };
  290. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  291. template <class Result, class Arg1 = Result, class Arg2 = Arg1>
  292. #else
  293. template <class Result, class Arg1, class Arg2>
  294. #endif
  295. struct constant_binary_fun : public binary_function<Arg1, Arg2, Result> {
  296.   Result val;
  297.   constant_binary_fun(const Result& v) : val(v) {}
  298.   const Result& operator()(const Arg1&, const Arg2&) const {
  299.     return val;
  300.   }
  301. };
  302. template <class Result>
  303. inline constant_void_fun<Result> constant0(const Result& val)
  304. {
  305.   return constant_void_fun<Result>(val);
  306. }
  307. template <class Result>
  308. inline constant_unary_fun<Result,Result> constant1(const Result& val)
  309. {
  310.   return constant_unary_fun<Result,Result>(val);
  311. }
  312. template <class Result>
  313. inline constant_binary_fun<Result,Result,Result> constant2(const Result& val)
  314. {
  315.   return constant_binary_fun<Result,Result,Result>(val);
  316. }
  317. // Note: this code assumes that int is 32 bits.
  318. class subtractive_rng : public unary_function<unsigned int, unsigned int> {
  319. private:
  320.   unsigned int table[55];
  321.   size_t index1;
  322.   size_t index2;
  323. public:
  324.   unsigned int operator()(unsigned int limit) {
  325.     index1 = (index1 + 1) % 55;
  326.     index2 = (index2 + 1) % 55;
  327.     table[index1] = table[index1] - table[index2];
  328.     return table[index1] % limit;
  329.   }
  330.   void initialize(unsigned int seed)
  331.   {
  332.     unsigned int k = 1;
  333.     table[54] = seed;
  334.     size_t i;
  335.     for (i = 0; i < 54; i++) {
  336.         size_t ii = (21 * (i + 1) % 55) - 1;
  337.         table[ii] = k;
  338.         k = seed - k;
  339.         seed = table[ii];
  340.     }
  341.     for (int loop = 0; loop < 4; loop++) {
  342.         for (i = 0; i < 55; i++)
  343.             table[i] = table[i] - table[(1 + i + 30) % 55];
  344.     }
  345.     index1 = 0;
  346.     index2 = 31;
  347.   }
  348.   subtractive_rng(unsigned int seed) { initialize(seed); }
  349.   subtractive_rng() { initialize(161803398u); }
  350. };
  351. // Adaptor function objects: pointers to member functions.
  352. // There are a total of 16 = 2^4 function objects in this family.
  353. //  (1) Member functions taking no arguments vs member functions taking
  354. //       one argument.
  355. //  (2) Call through pointer vs call through reference.
  356. //  (3) Member function with void return type vs member function with
  357. //      non-void return type.
  358. //  (4) Const vs non-const member function.
  359. // Note that choice (4) is not present in the 8/97 draft C++ standard, 
  360. //  which only allows these adaptors to be used with non-const functions.
  361. //  This is likely to be recified before the standard becomes final.
  362. // Note also that choice (3) is nothing more than a workaround: according
  363. //  to the draft, compilers should handle void and non-void the same way.
  364. //  This feature is not yet widely implemented, though.  You can only use
  365. //  member functions returning void if your compiler supports partial
  366. //  specialization.
  367. // All of this complexity is in the function objects themselves.  You can
  368. //  ignore it by using the helper function mem_fun, mem_fun_ref,
  369. //  mem_fun1, and mem_fun1_ref, which create whichever type of adaptor
  370. //  is appropriate.
  371. template <class S, class T>
  372. class mem_fun_t : public unary_function<T*, S> {
  373. public:
  374.   explicit mem_fun_t(S (T::*pf)()) : f(pf) {}
  375.   S operator()(T* p) const { return (p->*f)(); }
  376. private:
  377.   S (T::*f)();
  378. };
  379. template <class S, class T>
  380. class const_mem_fun_t : public unary_function<const T*, S> {
  381. public:
  382.   explicit const_mem_fun_t(S (T::*pf)() const) : f(pf) {}
  383.   S operator()(const T* p) const { return (p->*f)(); }
  384. private:
  385.   S (T::*f)() const;
  386. };
  387. template <class S, class T>
  388. class mem_fun_ref_t : public unary_function<T, S> {
  389. public:
  390.   explicit mem_fun_ref_t(S (T::*pf)()) : f(pf) {}
  391.   S operator()(T& r) const { return (r.*f)(); }
  392. private:
  393.   S (T::*f)();
  394. };
  395. template <class S, class T>
  396. class const_mem_fun_ref_t : public unary_function<T, S> {
  397. public:
  398.   explicit const_mem_fun_ref_t(S (T::*pf)() const) : f(pf) {}
  399.   S operator()(const T& r) const { return (r.*f)(); }
  400. private:
  401.   S (T::*f)() const;
  402. };
  403. template <class S, class T, class A>
  404. class mem_fun1_t : public binary_function<T*, A, S> {
  405. public:
  406.   explicit mem_fun1_t(S (T::*pf)(A)) : f(pf) {}
  407.   S operator()(T* p, A x) const { return (p->*f)(x); }
  408. private:
  409.   S (T::*f)(A);
  410. };
  411. template <class S, class T, class A>
  412. class const_mem_fun1_t : public binary_function<const T*, A, S> {
  413. public:
  414.   explicit const_mem_fun1_t(S (T::*pf)(A) const) : f(pf) {}
  415.   S operator()(const T* p, A x) const { return (p->*f)(x); }
  416. private:
  417.   S (T::*f)(A) const;
  418. };
  419. template <class S, class T, class A>
  420. class mem_fun1_ref_t : public binary_function<T, A, S> {
  421. public:
  422.   explicit mem_fun1_ref_t(S (T::*pf)(A)) : f(pf) {}
  423.   S operator()(T& r, A x) const { return (r.*f)(x); }
  424. private:
  425.   S (T::*f)(A);
  426. };
  427. template <class S, class T, class A>
  428. class const_mem_fun1_ref_t : public binary_function<T, A, S> {
  429. public:
  430.   explicit const_mem_fun1_ref_t(S (T::*pf)(A) const) : f(pf) {}
  431.   S operator()(const T& r, A x) const { return (r.*f)(x); }
  432. private:
  433.   S (T::*f)(A) const;
  434. };
  435. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  436. template <class T>
  437. class mem_fun_t<void, T> : public unary_function<T*, void> {
  438. public:
  439.   explicit mem_fun_t(void (T::*pf)()) : f(pf) {}
  440.   void operator()(T* p) const { (p->*f)(); }
  441. private:
  442.   void (T::*f)();
  443. };
  444. template <class T>
  445. class const_mem_fun_t<void, T> : public unary_function<const T*, void> {
  446. public:
  447.   explicit const_mem_fun_t(void (T::*pf)() const) : f(pf) {}
  448.   void operator()(const T* p) const { (p->*f)(); }
  449. private:
  450.   void (T::*f)() const;
  451. };
  452. template <class T>
  453. class mem_fun_ref_t<void, T> : public unary_function<T, void> {
  454. public:
  455.   explicit mem_fun_ref_t(void (T::*pf)()) : f(pf) {}
  456.   void operator()(T& r) const { (r.*f)(); }
  457. private:
  458.   void (T::*f)();
  459. };
  460. template <class T>
  461. class const_mem_fun_ref_t<void, T> : public unary_function<T, void> {
  462. public:
  463.   explicit const_mem_fun_ref_t(void (T::*pf)() const) : f(pf) {}
  464.   void operator()(const T& r) const { (r.*f)(); }
  465. private:
  466.   void (T::*f)() const;
  467. };
  468. template <class T, class A>
  469. class mem_fun1_t<void, T, A> : public binary_function<T*, A, void> {
  470. public:
  471.   explicit mem_fun1_t(void (T::*pf)(A)) : f(pf) {}
  472.   void operator()(T* p, A x) const { (p->*f)(x); }
  473. private:
  474.   void (T::*f)(A);
  475. };
  476. template <class T, class A>
  477. class const_mem_fun1_t<void, T, A> : public binary_function<const T*, A, void> {
  478. public:
  479.   explicit const_mem_fun1_t(void (T::*pf)(A) const) : f(pf) {}
  480.   void operator()(const T* p, A x) const { (p->*f)(x); }
  481. private:
  482.   void (T::*f)(A) const;
  483. };
  484. template <class T, class A>
  485. class mem_fun1_ref_t<void, T, A> : public binary_function<T, A, void> {
  486. public:
  487.   explicit mem_fun1_ref_t(void (T::*pf)(A)) : f(pf) {}
  488.   void operator()(T& r, A x) const { (r.*f)(x); }
  489. private:
  490.   void (T::*f)(A);
  491. };
  492. template <class T, class A>
  493. class const_mem_fun1_ref_t<void, T, A> : public binary_function<T, A, void> {
  494. public:
  495.   explicit const_mem_fun1_ref_t(void (T::*pf)(A) const) : f(pf) {}
  496.   void operator()(const T& r, A x) const { (r.*f)(x); }
  497. private:
  498.   void (T::*f)(A) const;
  499. };
  500. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  501. // Mem_fun adaptor helper functions.  There are only four:
  502. //  mem_fun, mem_fun_ref, mem_fun1, mem_fun1_ref.
  503. template <class S, class T>
  504. inline mem_fun_t<S,T> mem_fun(S (T::*f)()) { 
  505.   return mem_fun_t<S,T>(f);
  506. }
  507. template <class S, class T>
  508. inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const) {
  509.   return const_mem_fun_t<S,T>(f);
  510. }
  511. template <class S, class T>
  512. inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()) { 
  513.   return mem_fun_ref_t<S,T>(f);
  514. }
  515. template <class S, class T>
  516. inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const) {
  517.   return const_mem_fun_ref_t<S,T>(f);
  518. }
  519. template <class S, class T, class A>
  520. inline mem_fun1_t<S,T,A> mem_fun1(S (T::*f)(A)) { 
  521.   return mem_fun1_t<S,T,A>(f);
  522. }
  523. template <class S, class T, class A>
  524. inline const_mem_fun1_t<S,T,A> mem_fun1(S (T::*f)(A) const) {
  525.   return const_mem_fun1_t<S,T,A>(f);
  526. }
  527. template <class S, class T, class A>
  528. inline mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A)) { 
  529.   return mem_fun1_ref_t<S,T,A>(f);
  530. }
  531. template <class S, class T, class A>
  532. inline const_mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A) const) {
  533.   return const_mem_fun1_ref_t<S,T,A>(f);
  534. }
  535. __STL_END_NAMESPACE
  536. #endif /* __SGI_STL_INTERNAL_FUNCTION_H */
  537. // Local Variables:
  538. // mode:C++
  539. // End: