最終更新日時:
が更新

履歴 編集

Boost.Function Reference Manual

Header <boost/function.hpp> synopsis

以下で、 MAX_ARGS は実装定義の定数であり、 Boost.Function でサポートされる引数の数の最大値 (少なくとも 10) である。このドキュメント中で参照される MAX_ARGS 定数は、ライブラリ中で直接的には定義されていない。

namespace boost {
  class function_base
  {
    typedef implementation-defined safe_bool;
    bool empty() const;
  };

  // [0, MAX_ARGS] の範囲の全ての N について
  template<typename Signature,
           typename Arg1,
       typename Arg2,
           ...
           typename ArgN,
       typename Policy    = empty_function_policy, // 推奨されない
       typename Mixin     = empty_function_mixin, // 推奨されない
       typename Allocator = std::allocator<function_base> >
  class functionN : public function_base, public Mixin
  {
    typedef ResultType result_type; // [1]
    typedef Policy     policy_type; // 推奨されない
    typedef Mixin      mixin_type; // 推奨されない
    typedef Allocator  allocator_type;

    typedef Arg1 argument_type;        // N == 1 の場合

    typedef Arg1 first_argument_type;  // N == 2 の場合
    typedef Arg2 second_argument_type; // N == 2 の場合

    typedef Arg1 arg1_type;
    typedef Arg2 arg2_type;
             .
             .
             .
    typedef ArgN argN_type;

    enum { arity = N };

    // 構築
    explicit functionN(const Mixin& = Mixin());
    functionN(const functionN&);
    template<typename F> functionN(F, const Mixin& = Mixin());
    template<typename F> functionN(reference_wrapper<F>);

    // 代入
    functionN& operator=(const functionN&);
    template<typename F> functionN& operator=(F);
    template<typename F> functionN& operator=(reference_wrapper<F>);
    void set(const functionN&); // 推奨されない
    template<typename F> void set(F); // 推奨されない
    void swap(functionN&);
    void clear();

    // bool 型の文脈
    operator safe_bool() const;
    bool operator!() const;

    // 呼び出し
    result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
  };

  template<typename ResultType,
           typename Arg1,
       typename Arg2,
           ...
       typename ArgN,
           typename Policy, // 推奨されない
           typename Mixin, // 推奨されない
           typename Allocator>
  void swap(functionN<ResultType, Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&,
            functionN<ResultType, Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&);

  // [0, MAX_ARGS] の範囲の全ての N について
  template<typename Signature, // 関数型: ResultType (Arg1, Arg2, ..., ArgN)
       typename Policy    = empty_function_policy, // 推奨されない
       typename Mixin     = empty_function_mixin, // 推奨されない
       typename Allocator = std::allocator<function_base> >
  class function : public functionN<ResultType, Arg1, Arg2, ..., ArgN>
  {
    // 構築
    function();
    function(const function&);
    function(const functionN<ResultType, Arg1, Arg2, ..., ArgN>&);
    template<typename F> functionN(F);

    // 代入
    function& operator=(const function&);
    function& operator=(const functionN<ResultType, Arg1, Arg2, ..., ArgN>&);
    template<typename F> function& operator=(F);
    void set(const function&); // 推奨されない
    void set(const functionN<ResultType, Arg1, Arg2, ..., ArgN>&); // 推奨されない
    template<typename F> void set(F); // 推奨されない
  };

  template<typename Signature, typename Policy, typename Mixin, typename Allocator>
  void swap(function<Signature, Policy, Mixin, Allocator>&,
            function<Signature, Policy, Mixin, Allocator>&);
}

定義

  • 引数型 Arg1, Arg2, ..., ArgN と戻り値型 ResultType に対して、該当する以下の関数が適格な時、関数オブジェクト f は「 互換性がある 」という。

    // 関数型が void 以外の場合
    ResultType foo(Arg1 arg1, Arg2 arg2, ..., ArgN argN)
    {
      return f(arg1, arg2, ..., argN);
    }
    
    // 関数型が void の場合
    ResultType foo(Arg1 arg1, Arg2 arg2, ..., ArgN argN)
    {
      f(arg1, arg2, ..., argN);
    }
    

    メンバ関数ポインタには、特別な規定がある。メンバ関数ポインタは関数オブジェクトではないが、 Boost.Function は内部的にメンバ関数ポインタを関数オブジェクトに作り変える。 R (X::*mf)(Arg1, Arg2, ..., ArgN) cv-quals の形のメンバ関数ポインタは、以下のように関数呼出し演算子をオーバロードした関数オブジェクトに作り変えられる。

    template<typename P>
    R operator()(cv-quals P& x, Arg1 arg1, Arg2 arg2, ..., ArgN argN) const
    {
      return (*x).*mf(arg1, arg2, ..., argN);
    }
    

  • F が関数ポインタであるか、 boost::is_stateless<T> が真の時、 F 型の関数オブジェクト f は「 状態を持たない 」という。状態を持たない関数オブジェクトの Boost.Function での構築/コピーは発生せず、例外は起きず、記憶域の割り当ても起きない。

Class function_base

クラス function_base は全ての Boost.Function オブジェクトに共通する基底クラスだ。 function_base 型のオブジェクトが直接作られることはないだろう。

bool empty() const

  • 戻り値: 関数オブジェクトを格納していれば true 、そうでなければ false
  • 例外: 例外を起こさない。

Class template functionN

クラステンプレート functionN は実際には、 function0, function1, ... と、ある実装定義の最大値まで続く、関連するクラス群である。以下の文では、 N はパラメータの数、 f は暗黙のオブジェクトパラメータを表す。

explicit functionN(const Mixin& = Mixin());

  • 作用: 与えられたミックスインから Mixin 型サブオブジェクトを構築する。
  • 事後条件: f.empty()
  • 例外: Mixin 型サブオブジェクトの構築で例外が起きない限り、例外を起こさない。

functionN(const functionN& g);

  • 事後条件: g が空でなければ、 fg が格納する関数オブジェクトのコピーを格納する。 g.empty() ならば f も空になる。 f のミックスインは、 g のミックスインからコピーされる。
  • 例外: g が格納する関数オブジェクトのコピーや Mixin 型サブオブジェクトの構築で例外が起きない限り、例外を起こさない。

template<typename F> functionN(F g, const Mixin& = Mixin());

  • 必須事項: g互換性がある関数オブジェクトであること。
  • 作用: 与えられたミックスインから Mixin 型サブオブジェクトを構築する。
  • 事後条件: g が空でなければ、 fg のコピーを格納する。 g が空ならば、 f.empty() が真となる。
  • 例外: Mixin 型サブオブジェクトの構築で例外が起きず、 g が状態を持たない関数オブジェクトならば、例外を起こさない。

template<typename F> functionN(reference_wrapper<F> g);

  • 必須事項: g.get()互換性がある関数オブジェクトであること。
  • 作用: 与えられたミックスインから Mixin 型サブオブジェクトを構築する。
  • 事後条件: g.get() が空でなければ、 thisg (g.get()のコピーではない) を格納する。 g.get() が空ならば、 this->empty() が真となる。
  • 例外: Mixin 型サブオブジェクトの構築で例外が起きない限り、例外を起こさない。

functionN& operator=(const functionN& g);

  • 事後条件: g が空でなければ、 fg が格納する関数オブジェクトのコピーを格納する。 g.empty() ならば、 f も空になる。 f のミックスインには g のミックスインが代入される。
  • 戻り値: *this
  • 例外: g状態を持たない関数オブジェクトを格納しているか、 g が関数オブジェクトへの参照を格納してる場合は、例外を起こさない。ただし、 Mixin 型サブオブジェクトのコピーで例外が起きた場合を除く。

template<typename F> functionN& operator=(F g);

  • 必須事項: g は互換性がある関数オブジェクトであること。
  • 事後条件: g が空でなければ、 fg のコピーを格納する。 g が空ならば、 f.empty() が真となる。
  • 戻り値: *this
  • 例外: g が状態を持たない関数オブジェクトを格納していれば、例外を起こさない。

template<typename F> functionN& operator=(reference_wrapper<F> g);

  • 必須事項: g.get() が互換性がある関数オブジェクトであること。
  • 事後条件: g.get() が空でなければ、 fg.get() ( g.get() のコピーではない) を格納する。 g.get() が空ならば、 f.empty() が真となる。
  • 戻り値: *this
  • 例外: this が格納していた関数オブジェクトの破棄で例外が起きた場合のみ、例外を起こす。

void set(const functionN& g);

  • 作用: *this = g
  • 注意: この関数の使用は推奨されない。この関数は Boost.Function の将来のバージョンで削除される。代わりに代入演算子を使って欲しい。

template<typename F> void set(F g);

  • 作用: *this = g
  • 注意: この関数の使用は推奨されない。この関数は Boost.Function の将来のバージョンで削除される。代わりに代入演算子を使って欲しい。

void swap(functionN& g);

  • 作用: fg が格納する関数オブジェクトを交換し、 fg のミックスインを交換する。
  • 例外: 例外は発生しない。

void clear();

  • 作用: !empty()ならば、格納する関数オブジェクトを破棄する。
  • 事後条件: empty()が真になる。

operator safe_bool() const;

  • 戻り値: !empty()と等価なsafe_bool
  • 例外: 例外は発生しない。
  • 注意: safe_bool 型は bool 型が予想される場所 (例: if の条件) に使用できる。しかし、 bool 型で起きる暗黙の型変換 (例: int型への変換) は許されない。これによってユーザの間違いの元を減らせることがある。

bool operator!() const

  • 戻り値: this->empty()
  • 例外: 例外は発生しない。

result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;

  • 必須事項: !empty()
  • 作用: 以下で、 target は格納された関数オブジェクトである。 target 変数には const 修飾子や volatile 修飾子が付いていない (ので、関数呼出し演算子に const 修飾子や volatile 修飾子が付いている必要はない) 。
    1. policy_type policy;
    2. policy.precall(this);
    3. target(a1, a2, ..., aN);
    4. policy.postcall(this);
  • 戻り値: target の戻り値。
  • 注意: 呼び出しポリシーは推奨されなくなり、今後のリリースで削除される。

Class template function

クラステンプレート function は、番号付きクラステンプレート function0, function1, ... の薄いラッパである。 MAX_ARGS までの引数を受け付ける。 N 個の引数を渡されれば、 functionN (引数 N 個専用のクラス) から派生する。

クラステンプレート function のメンバ関数のセマンティクスは、全て functionN オブジェクトと同じである。ただし、 function オブジェクトの正しいコピーコンストラクトやコピーの代入のために、追加のメンバ関数を定義している。

Operations

template<typename ResultType,
         typename Arg1,
     typename Arg2,
         ...
     typename ArgN,
         typename Policy, // 推奨されない
         typename Mixin, // 推奨されない
         typename Allocator>
void swap(functionN<ResultType, Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& f,
          functionN<ResultType, Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& g);

  • 作用: f.swap(g);

template<typename Signature, typename Policy, typename Mixin, typename Allocator>
void swap(function<Signature, Policy, Mixin, Allocator>& f,
          function<Signature, Policy, Mixin, Allocator>& g);

  • 作用: f.swap(g);

脚注

  • [1] : コンパイラが void 型の return をサポートしていない場合、 ReturnTypevoid を指定すると、 Boost.Function オブジェクトの result_type は実装依存になる。

Douglas Gregor

Last modified: Fri Oct 11 05:40:09 EDT 2002

Japanese Translation Copyright © 2003 Hiroshi Ichikawa

オリジナルの、及びこの著作権表示が全ての複製の中に現れる限り、この文書の複製、利用、変更、販売そして配布を認める。このドキュメントは「あるがまま」に提供されており、いかなる明示的、暗黙的保証も行わない。また、いかなる目的に対しても、その利用が適していることを関知しない。

このドキュメントの対象: Boost Version 1.29.0