STLリファレンス

<functional>

[unary_function,binary_function]

- template <class Arg, class Result>
  struct unary_function {
    typedef Arg    argument_type;
    typedef Result result_type;
  };

- template <class Arg1, class Arg2, class Result>
  struct binary_function {
    typedef Arg1   first_argument_type;
    typedef Arg2   second_argument_type;
    typedef Result result_type;
  };
unary_function,binary_functionは単項/二項関数オブジェクトのベースとなるクラスです。

[plus,minus,multiplies,divides,modudus,negate]

- template <class T>
  struct plus : binary_function<T,T,T> {
    T operator()(const T& x, const T& y) const;
  };

 T plus<T>::operator()(const T& x, const T& y) const;
x + y を返します。
- template <class T>
  struct minus : binary_function<T,T,T> {
    T operator()(const T& x, const T& y) const;
  };

 T minus<T>::operator()(const T& x, const T& y) const;
x - y を返します。
- template <class T>
  struct multiplies : binary_function<T,T,T> {
    T operator()(const T& x, const T& y) const;
  };

 T multilies<T>::operator()(const T& x, const T& y) const;
x * y を返します。
- template <class T>
  struct divides : binary_function<T,T,T> {
    T operator()(const T& x, const T& y) const;
  };

 T divides<T>::operator()(const T& x, const T& y) const;
x / y を返します。
- template <class T>
  struct modulus : binary_function<T,T,T> {
    T operator()(const T& x, const T& y) const;
  };

 T modulus<T>::operator()(const T& x, const T& y) const;
x % y を返します。
- template <class T>
  struct negate : unary_function<T,T> {
    T operator()(const T& x) const;
  };

 T negate<T>::operator()(const T& x) const;
-x を返します。
  // 関数オブジェクトによる加減乗除
  plus<int>  add;
  minus<int> sub;
  multiplies<int> mul;
  divides<int>    div;
  modulus<int>    mod;
  negate<int>     neg;
  int a = 17;
  int b = 3;
  cout << a << '+' << b << '=' << add(a,b) << endl;
  cout << a << '-' << b << '=' << sub(a,b) << endl;
  cout << a << '*' << b << '=' << mul(a,b) << endl;
  cout << a << '/' << b << '=' << div(a,b) << endl;
  cout << a << '%' << b << '=' << mod(a,b) << endl;
  cout << '-' << a << '=' << neg(a) << endl;

  実行結果:
    17+3=20
    17-3=14
    17*3=51
    17/3=5
    17%3=2
    -17=-17

[equal_to,not_equal_to,greater,less,greater_equal,less_equal]

- template <class T>
  struct equal_to : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool equal_to<T>::operator()(const T& x, const T& y) const;
x == y を返します。
- template <class T>
  struct not_equal_to : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool not_equal_to<T>::operator()(const T& x, const T& y) const;
x != y を返します。
- template <class T>
  struct greater : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool greater<T>::operator()(const T& x, const T& y) const;
x > y を返します。
- template <class T>
  struct less : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool less<T>::operator()(const T& x, const T& y) const;
x < y を返します。
- template <class T>
  struct greater_equal : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool greater_equal<T>::operator()(const T& x, const T& y) const;
x >= y を返します。
- template <class T>
  struct less_equal : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool less_equal<T>::operator()(const T& x, const T& y) const;
x <= y を返します。
  // 関数オブジェクトによる比較
  equal_to<int>      eq;
  not_equal_to<int>  ne;
  greater<int>       gt;
  less<int>          lt;
  greater_equal<int> ge;
  less_equal<int>    le;
  int a = 17;
  int b = 3;
  cout.setf(ios::boolalpha);
  cout << a << "==" << b << ':' << eq(a,b) << endl;
  cout << a << "!=" << b << ':' << ne(a,b) << endl;
  cout << a << "> " << b << ':' << gt(a,b) << endl;
  cout << a << "< " << b << ':' << lt(a,b) << endl;
  cout << a << ">=" << b << ':' << ge(a,b) << endl;
  cout << a << "<=" << b << ':' << le(a,b) << endl;

  実行結果:
    17==3:false
    17!=3:true
    17> 3:true
    17< 3:false
    17>=3:true
    17<=3:false

[logical_and,logical_or,logical_not]

- template <class T>
  struct logical_and : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool logical_and<T>::operator()(const T& x, const T& y) const;
x && y を返します。
- template <class T>
  struct logical_or : binary_function<T,T,bool> {
    bool operator()(const T& x, const T& y) const;
  };

 bool logical_or<T>::operator()(const T& x, const T& y) const;
x || y を返します。
- template <class T>
  struct logical_not : unary_function<T,bool> {
    bool operator()(const T& x) const;
  };

 bool logical_not<T>::operator()(const T& x) const;
!x を返します。

[unary_negate,not1]

- template <class Predicate>
  class unary_negate
    : public unary_function<typename Predicate::argument_type,bool> {
  public:
    explicit unary_negate(const Predicate& pred);
    bool operator()(const typename Predicate::argument_type& x) const;
  };

 bool unarey_negate<Predicate>::operator()(
          const typename Predicate::argument_type& x) const;
!pred(x) を返します。
- template <class Predicate>
  unary_negate<Predicate>
  not1(const Predicate& pred);
unary_negate<Predicate>(pred) を返します。

[binary_negate,not2]

- template <class Predicate>
  class binary_negate
    : public binary_function<typename Predicate::first_argument_type,
        typename Predicate::second_argument_type, bool> {
  public:
    explicit binary_negate(const Predicate& pred);
    bool operator()(const typename Predicate::first_argument_type&  x,
        const typename Predicate::second_argument_type& y) const;
  };

 bool binary_negate<Predicate>::operator()(
          const typename Predicate::first_argument_type&  x,
          const typename Predicate::second_argument_type& y) const;
!pred(x,y) を返します。
- template <class Predicate>
  binary_negate<Predicate>
  not2(const Predicate& pred);
binary_negate<Predicate>(pred) を返します。

[binder1st,bind1st]

- 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);
    typename Operation::result_type
      operator()(const typename Operation::second_argument_type& x) const;
  };

 typename Operation::result_type
 binder1st<Operation>::operator()(
          const typename Operation::second_argument_type& x) const;
op(value,x) を返します。
- template <class Operation, class T>
  binder1st<Operation>
  bind1st(const Operation& op, const T& x);
binder1st<Operation>(op, typename Operation::first_argument_type(x)) を返します。

[binder2nd,bind2nd]

- template <class Operation>
  class binder2nd
    : public unary_function<typename Operation::first_argument_type,
                            typename Operation::result_type> {
  protected:
    Operation                       op;
    typename Operation::second_argument_type value;
  public:
    binder2nd(const Operation& x,
              const typename Operation::second_argument_type& y);
    typename Operation::result_type
      operator()(const typename Operation::first_argument_type& x) const;
  };

 typename Operation::result_type
 binder2nd<Operation>::operator()(
        const typename Operation::first_argument_type& x) const;
op(x,value) を返します。
- template <class Operation, class T>
  binder2nd<Operation>
  bind2nd(const Operation& op, const T& x);
binder2nd<Operation>(op, typename Operation::second_argument_type(x)) を返します。

[pointer_to_unary_function,ptr_fun]

- template <class Arg, class Result>
  class pointer_to_unary_function : public unary_function<Arg, Result> {
  public:
    explicit pointer_to_unary_function(Result (*f)(Arg));
    Result operator()(Arg x) const;
  };

 Result pointer_to_unary_function<Arg,Result>::operator()(Arg x) const;
f(x) を返します。
- template <class Arg, class Result>
  pointer_to_unary_function<Arg, Result>
  ptr_fun(Result (*f)(Arg));
pointer_to_unary_function<Arg, Result>(f) を返します。

[pointer_to_binary_function,ptr_fun]

- template <class Arg1, class Arg2, class Result>
  class pointer_to_binary_function :
    public binary_function<Arg1,Arg2,Result> {
  public:
    explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
    Result operator()(Arg1 x, Arg2 y) const;
  };

 Result pointer_to_binary_function<Arg1,Arg2,,Result>::operator()(
             Arg1 x, Arg2 y) const;
f(x,y) を返します。
- template <class Arg1, class Arg2, class Result>
  pointer_to_binary_function<Arg1,Arg2,Result>
  ptr_fun(Result (*f)(Arg1, Arg2));
pointer_to_binary_function<Arg1,Arg2,Result>(f) を返します。

[mem_fun_t,mem_fun1_t,mem_fun]

- template <class S, class T>
  class mem_fun_t : public unary_function<T*, S> {
  public:
    explicit mem_fun_t(S (T::*f)());
    S operator()(T* p) const;
  };

 S mem_fun_t<S,T>::operator()(T* p) const;
(p->*f)() を返します。
- template <class S, class T, class A>
  class mem_fun1_t : public binary_function<T*, A, S> {
  public:
    explicit mem_fun1_t(S (T::*f)(A));
    S operator()(T* p, A x) const;
  };

- S mem_fun1_t<S,T,A>::operator()(T* p, A x) const;
(p->*f)(x) を返します。
- template<class S, class T>
  mem_fun_t<S,T>
  mem_fun(S (T::*f)());
mem_fun_t<S,T>(f) を返します。
- template<class S, class T, class A>
  mem_fun1_t<S,T,A>
  mem_fun(S (T::*f)(A));
mem_fun1_t<S,T,A>(f) を返します。

[mem_fun_ref_t,mem_fun1_ref_t,mem_fun_ref]

- template <class S, class T>
  class mem_fun_ref_t : public unary_function<T, S> {
  public:
    explicit mem_fun_ref_t(S (T::*f)());
    S operator()(T& p) const;
  };

 S mem_fun_ref_t<S,T>::operator()(T& p) const;
(p.*f)() を返します。
- template <class S, class T, class A>
  class mem_fun1_ref_t : public binary_function<T, A, S> {
  public:
    explicit mem_fun1_ref_t(S (T::*f)(A));
    S operator()(T& p, A x) const;
  };

 S mem_fun1_ref_t<S,T,A>::operator()(T& p, A x) const;
(p.*f)(x) を返します。
- template<class S, class T>
  mem_fun_ref_t<S,T>
  mem_fun_ref(S (T::*f)());
mem_fun_ref_t<S,T>(f) を返します。
- template<class S, class T, class A>
  mem_fun1_ref_t<S,T,A>
  mem_fun_ref(S (T::*f)(A));
mem_fun1_ref_t<S,T,A>(f) を返します。

[const_mem_fun_t,const_mem_fun1_t,mem_fun]

- template <class S, class T>
  class const_mem_fun_t : public unary_function<T*, S> {
  public:
    explicit const_mem_fun_t(S (T::*f)() const);
    S operator()(const T* p) const;
  };

 S const_mem_fun_t<S,T>::operator()(const T* p) const;
(p->*f)() を返します。
- template <class S, class T, class A>
  class const_mem_fun1_t : public binary_function<T*, A, S> {
  public:
    explicit const_mem_fun1_t(S (T::*p)(A) const);
    S operator()(const T* p, A x) const;
  };

 S const_mem_fun_t<S,T>::operator()(const T* p, A x) const;
(p->*f)(x) を返します。
- template<class S, class T>
  const_mem_fun_t<S,T>
  mem_fun(S (T::*f)() const);
const_mem_fun_t<S,T>(f) を返します。
- template<class S, class T, class A>
  const_mem_fun1_t<S,T,A>
  mem_fun(S (T::*f)(A) const);
const_mem_fun1_t<S,T,A>(f) を返します。

[const_mem_fun_ref_t,const_mem_fun1_ref_t,mem_fun_ref]

- template <class S, class T>
  class const_mem_fun_ref_t : public unary_function<T, S> {
  public:
    explicit const_mem_fun_ref_t(S (T::*f)() const);
    S operator()(const T& p) const;
  };

 S const_mem_fun_ref_t<S,T>::operator()(const T& p) const;
(p.*f)() を返します。
- template <class S, class T, class A>
  class const_mem_fun1_ref_t : public binary_function<T, A, S> {
  public:
    explicit const_mem_fun1_ref_t(S (T::*f)(A) const);
    S operator()(const T& p, A x) const;
  };

 S const_mem_fun1_ref_t<S,T,A>::operator()(const T& p, A x) const;
(p.*f)(x) を返します。
- template<class S, class T>
  const_mem_fun_ref_t<S,T>
  mem_fun_ref(S (T::*f)() const);
const_mem_fun_ref_t<S,T>(f) を返します。
- template<class S, class T, class A>
  const_mem_fun1_ref_t<S,T,A>
  mem_fun_ref(S (T::*f)(A) const);
const_mem_fun1_ref_t<S,T,A>(f) を返します。