Reference（參考）

Definitions（定義）
Header <boost/function.hpp>（頭文件 <boost/function.hpp>）
Header <boost/function_equal.hpp>（頭文件 <boost/function_equal.hpp>）

Definitions（定義）

如果對於給定的一套參數類型 Arg1, Arg2, ..., ArgN 和返回類型 ResultType，適合於以下形式，則可以說這個函數對像 f 是 compatible（兼容）的：
```
  // if ResultType is not void
  ResultType foo(Arg1 arg1, Arg2 arg2, ..., ArgN argN)
  {
    return f(arg1, arg2, ..., argN);
  }

  // if ResultType is 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 的函數對像 f 是一個函數指針或者 boost::is_stateless<T> 為 true，則這個函數對象是 stateless 的。一個 stateless 函數對象的構造函數或者將 stateless 函數對像拷貝到 Boost.Function 對像中不會拋出異常，而且不分配任何存儲空間。

Header <boost/function.hpp>（頭文件 <boost/function.hpp>）

namespace boost {
  class bad_function_call;
  class function_base;
  template<typename R, typename T1, typename T2, ..., typename TN> 
    class functionN;
  template<typename T1, typename T2, ..., typename TN> 
    void swap(functionN<T1, T2, ..., TN>&, functionN<T1, T2, ..., TN>&);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator==(const functionN<T1, T2, ..., TN>&, Functor);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator==(Functor, const functionN<T1, T2, ..., TN>&);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator==(const functionN<T1, T2, ..., TN>&, 
                    reference_wrapper<Functor>);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator==(reference_wrapper<Functor>, 
                    const functionN<T1, T2, ..., TN>&);
  template<typename T1, typename T2, ..., typename TN,  
           typename U1, typename U2, ..., typename UN> 
    void operator==(const functionN<T1, T2, ..., TN>&, 
                    const functionN<U1, U2, ..., UN>&);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator!=(const functionN<T1, T2, ..., TN>&, Functor);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator!=(Functor, const functionN<T1, T2, ..., TN>&);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator!=(const functionN<T1, T2, ..., TN>&, 
                    reference_wrapper<Functor>);
  template<typename T1, typename T2, ..., typename TN, typename Functor> 
    bool operator!=(reference_wrapper<Functor>, 
                    const functionN<T1, T2, ..., TN>&);
  template<typename T1, typename T2, ..., typename TN, 
           typename U1, typename U2, ..., typename UN> 
    void operator!=(const functionN<T1, T2, ..., TN>&, 
                    const functionN<U1, U2, ..., UN>&);
  template<typename Signature> 
    class function;
  template<typename Signature> 
    void swap(function<Signature>&, function<Signature>&);
  template<typename Signature, typename Functor> 
    bool operator==(const function<Signature>&, Functor);
  template<typename Signature, typename Functor> 
    bool operator==(Functor, const function<Signature>&);
  template<typename Signature, typename Functor> 
    bool operator==(const function<Signature>&, reference_wrapper<Functor>);
  template<typename Signature, typename Functor> 
    bool operator==(reference_wrapper<Functor>, const function<Signature>&);
  template<typename Signature1, typename Signature2> 
    void operator==(const function<Signature1>&, const function<Signature2>&);
  template<typename Signature, typename Functor> 
    bool operator!=(const function<Signature>&, Functor);
  template<typename Signature, typename Functor> 
    bool operator!=(Functor, const function<Signature>&);
  template<typename Signature, typename Functor> 
    bool operator!=(const function<Signature>&, reference_wrapper<Functor>);
  template<typename Signature, typename Functor> 
    bool operator!=(reference_wrapper<Functor>, const function<Signature>&);
  template<typename Signature1, typename Signature2> 
    void operator!=(const function<Signature1>&, const function<Signature2>&);
}

Header <boost/function_equal.hpp>（頭文件 <boost/function_equal.hpp>）

namespace boost {
  template<typename F, typename G> bool function_equal(const F&, const G&);
}