主頁 > 後端開發 > std::bind介面與實作

std::bind介面與實作

2020-09-15 05:47:47 後端開發

前言

最近想起半年前鴿下來的Haskell，重溫了一下忘得精光的語法，讀了幾個示例程式，挺帶感的，于是函式式編程的草就種得更深了，又去Google了一下C++與FP，找到了一份近乎完美的講義，然后被帶到C++20的ranges library，對即將發布的C++20滿懷憧憬，此時，我猛然間意識到，看別人做，覺得自己也能做好，在游戲界叫云玩家，在編程界就叫云程式員啊！

不行，得找點事干，想起同樣被我鴿了很久的<functional>系列，剛好與函式式編程搭點邊，就動筆寫吧！這就是本文的來歷，

找來GCC 8.1.0的標準庫，在<functional>中找到了std::bind的實作，花了好長時間終于讀懂了，原來std::bind的原理一點都不復雜，此外，std::bind的實作依賴于std::tuple，本文理應從后者開始講起，但是又看了看<tuple>的長度和難度，寫std::tuple未免喧賓奪主了，所以，本文將聚焦于std::bind的實作，其他標準庫組件就當現成的來用了，

介面

你能點開這篇文章，說明你一定明白std::bind是干什么用的，以及應該怎么用，我就不贅述了，簡而言之，std::bind用于給一個可呼叫物件系結引數，可呼叫物件包括函式物件（仿函式）、函式指標、函式參考、成員函式指標和資料成員指標，系結的引數可以是實際的引數，也可以是std::placeholders::_1等占位符，std::bind回傳一個函式物件，稱為“bind運算式”，它被呼叫時，先前系結的可呼叫物件被呼叫，引數為在std::bind中系結的引數，占位符用呼叫函式物件時傳入的引數替換，_1表示第一個引數，從1開始計數，呼叫時多余的引數會被求值然后忽略，

很抽象吧？看個例子：

#include <functional>
using namespace std::placeholders;

void f(int a, int b, int c, int d) { }

int main()
{
    auto g = std::bind(f, 42, _2, _1, 233);
    g(404, 10086, 114514);
}

這相當于呼叫f(42, 10086, 404, 233);，

我終究還是贅述了，那就讓贅述有點意義吧，明確兩個概念：系結引數，指呼叫std::bind時傳入的除第一個可呼叫物件以外的引數；呼叫引數，指呼叫std::bind回傳的函式物件時傳入的引數，

有三個你可能不知道的細節：

  1. 呼叫可呼叫物件時，系結引數被std::move，呼叫引數被std::forward，你得根據可呼叫物件的行為來判斷std::bind回傳的函式物件是否可以多次呼叫，

  2. 系結引數可以是bind運算式，占位符被替換為外層的呼叫引數，相當于用呼叫引數來呼叫這個bind運算式，求值后用來呼叫外層bind運算式——我是在讀原始碼讀到一半一臉懵逼的時候才知道這件事的，這與可呼叫物件被std::bind以后可以再std::bind并不沖突，因為bind運算式一個是作為系結引數，另一個是作為可呼叫物件，

  3. std::bind有個多載，可以用模板引數指定bind運算式的operator()的回傳型別，

下面的程式演示了后兩個功能：

#include <iostream>
#include <functional>
using namespace std::placeholders;

class A
{
public:
    A(int i) : i(i) { }
    friend std::ostream& operator<<(std::ostream&, const A&);
private:
    int i;
};

std::ostream& operator<<(std::ostream& os, const A& a)
{
    os << "A: " << a.i;
    return os;
}

int main()
{
    auto f = std::bind<A>(std::plus<int>(), 1, std::bind(std::multiplies<int>(), 2, _1));
    std::cout << f(3) << std::endl;
}

程式輸出A: 7，

還有兩個type traits：std::is_bind_expression，對std::bind的回傳型別其value為true；std::is_placeholder，對std::placeholders::_1的型別其value為1，以此類推，

實作

終于步入正題了，std::bind的實作原理并不復雜，但是標準庫要考慮各種奇葩情況，比如volatile和可變引數（如std::printf，而非變參模板）等，代碼就變長了很多（典型的有std::is_function），

為了講解與理解的方便，我把std::bind的實作分成5個層次：

  1. 工具：is_bind_expression、is_placeholder、namespace std::placeholders、_Safe_tuple_element_t和__volget，前兩個用于模板偏特化；

  2. _Mu：4種情況，分類討論；

  3. _Bind：_Bind和_Bind_result，std::bind的回傳型別；

  4. 輔助：_Bind_check_arity、__is_socketlike、_Bind_helper和_Bindres_helper；

  5. std::bind本尊，

總體上，_Bind保存可呼叫物件和系結引數，_Mu把系結引數轉換為實際引數，

工具

  /**
   *  @brief Determines if the given type _Tp is a function object that
   *  should be treated as a subexpression when evaluating calls to
   *  function objects returned by bind().
   *
   *  C++11 [func.bind.isbind].
   *  @ingroup binders
   */
  template<typename _Tp>
    struct is_bind_expression
    : public false_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Signature>
    struct is_bind_expression<_Bind<_Signature> >
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Signature>
    struct is_bind_expression<const _Bind<_Signature> >
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Signature>
    struct is_bind_expression<volatile _Bind<_Signature> >
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Signature>
    struct is_bind_expression<const volatile _Bind<_Signature>>
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Result, typename _Signature>
    struct is_bind_expression<_Bind_result<_Result, _Signature>>
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Result, typename _Signature>
    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Result, typename _Signature>
    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template<typename _Result, typename _Signature>
    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
    : public true_type { };



  /** @brief The type of placeholder objects defined by libstdc++.
   *  @ingroup binders
   */
  template<int _Num> struct _Placeholder { };

  /** @namespace std::placeholders
   *  @brief ISO C++11 entities sub-namespace for functional.
   *  @ingroup binders
   */
  namespace placeholders
  {
  /* Define a large number of placeholders. There is no way to
   * simplify this with variadic templates, because we're introducing
   * unique names for each.
   */
    extern const _Placeholder<1> _1;
    extern const _Placeholder<2> _2;
    extern const _Placeholder<3> _3;
    extern const _Placeholder<4> _4;
    extern const _Placeholder<5> _5;
    extern const _Placeholder<6> _6;
    extern const _Placeholder<7> _7;
    extern const _Placeholder<8> _8;
    extern const _Placeholder<9> _9;
    extern const _Placeholder<10> _10;
    extern const _Placeholder<11> _11;
    extern const _Placeholder<12> _12;
    extern const _Placeholder<13> _13;
    extern const _Placeholder<14> _14;
    extern const _Placeholder<15> _15;
    extern const _Placeholder<16> _16;
    extern const _Placeholder<17> _17;
    extern const _Placeholder<18> _18;
    extern const _Placeholder<19> _19;
    extern const _Placeholder<20> _20;
    extern const _Placeholder<21> _21;
    extern const _Placeholder<22> _22;
    extern const _Placeholder<23> _23;
    extern const _Placeholder<24> _24;
    extern const _Placeholder<25> _25;
    extern const _Placeholder<26> _26;
    extern const _Placeholder<27> _27;
    extern const _Placeholder<28> _28;
    extern const _Placeholder<29> _29;
  }

  /**
   *  @brief Determines if the given type _Tp is a placeholder in a
   *  bind() expression and, if so, which placeholder it is.
   *
   *  C++11 [func.bind.isplace].
   *  @ingroup binders
   */
  template<typename _Tp>
    struct is_placeholder
    : public integral_constant<int, 0>
    { };

  /**
   *  Partial specialization of is_placeholder that provides the placeholder
   *  number for the placeholder objects defined by libstdc++.
   *  @ingroup binders
   */
  template<int _Num>
    struct is_placeholder<_Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };

  template<int _Num>
    struct is_placeholder<const _Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };



#if __cplusplus > 201402L
  template <typename _Tp> inline constexpr bool is_bind_expression_v
    = is_bind_expression<_Tp>::value;
  template <typename _Tp> inline constexpr int is_placeholder_v
    = is_placeholder<_Tp>::value;
#endif // C++17



  // Like tuple_element_t but SFINAE-friendly.
  template<std::size_t __i, typename _Tuple>
    using _Safe_tuple_element_t
      = typename enable_if<(__i < tuple_size<_Tuple>::value),
                           tuple_element<__i, _Tuple>>::type::type;



  // std::get<I> for volatile-qualified tuples
  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }

  // std::get<I> for const-volatile-qualified tuples
  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(const volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }

這里好像沒什么值得講解的呢，注釋都寫得很清楚啦，

_Mu

  /**
   *  Maps an argument to bind() into an actual argument to the bound
   *  function object [func.bind.bind]/10. Only the first parameter should
   *  be specified: the rest are used to determine among the various
   *  implementations. Note that, although this class is a function
   *  object, it isn't entirely normal because it takes only two
   *  parameters regardless of the number of parameters passed to the
   *  bind expression. The first parameter is the bound argument and
   *  the second parameter is a tuple containing references to the
   *  rest of the arguments.
   */
  template<typename _Arg,
           bool _IsBindExp = is_bind_expression<_Arg>::value,
           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
    class _Mu;

  /**
   *  If the argument is reference_wrapper<_Tp>, returns the
   *  underlying reference.
   *  C++11 [func.bind.bind] p10 bullet 1.
   */
  template<typename _Tp>
    class _Mu<reference_wrapper<_Tp>, false, false>
    {
    public:
      /* Note: This won't actually work for const volatile
       * reference_wrappers, because reference_wrapper::get() is const
       * but not volatile-qualified. This might be a defect in the TR.
       */
      template<typename _CVRef, typename _Tuple>
        _Tp&
        operator()(_CVRef& __arg, _Tuple&) const volatile
        { return __arg.get(); }
    };

  /**
   *  If the argument is a bind expression, we invoke the underlying
   *  function object with the same cv-qualifiers as we are given and
   *  pass along all of our arguments (unwrapped).
   *  C++11 [func.bind.bind] p10 bullet 2.
   */
  template<typename _Arg>
    class _Mu<_Arg, true, false>
    {
    public:
      template<typename _CVArg, typename... _Args>
        auto
        operator()(_CVArg& __arg,
                   tuple<_Args...>& __tuple) const volatile
        -> decltype(__arg(declval<_Args>()...))
        {
          // Construct an index tuple and forward to __call
          typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
            _Indexes;
          return this->__call(__arg, __tuple, _Indexes());
        }

    private:
      // Invokes the underlying function object __arg by unpacking all
      // of the arguments in the tuple.
      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
        auto
        __call(_CVArg& __arg, tuple<_Args...>& __tuple,
               const _Index_tuple<_Indexes...>&) const volatile
        -> decltype(__arg(declval<_Args>()...))
        {
          return __arg(std::get<_Indexes>(std::move(__tuple))...);
        }
    };

  /**
   *  If the argument is a placeholder for the Nth argument, returns
   *  a reference to the Nth argument to the bind function object.
   *  C++11 [func.bind.bind] p10 bullet 3.
   */
  template<typename _Arg>
    class _Mu<_Arg, false, true>
    {
    public:
      template<typename _Tuple>
        _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
        operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
        {
          return
            ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
        }
    };

  /**
   *  If the argument is just a value, returns a reference to that
   *  value. The cv-qualifiers on the reference are determined by the caller.
   *  C++11 [func.bind.bind] p10 bullet 4.
   */
  template<typename _Arg>
    class _Mu<_Arg, false, false>
    {
    public:
      template<typename _CVArg, typename _Tuple>
        _CVArg&&
        operator()(_CVArg&& __arg, _Tuple&) const volatile
        { return std::forward<_CVArg>(__arg); }
    };

_Mu類模板用于轉換系結引數，該呼叫的呼叫，該替換的替換，_Mu其實只起到函式模板的作用，但是函式模板不能偏特化，就只能寫成類了，因此，_Mu只有默認的建構式，實體都是當即使用的（_Mu<T>()(...)），

_Mu有三個引數：_Arg是一個系結引數的型別；_IsBindExp指示它是否是bind運算式，之前提到這里的bind運算式需要求值后才能使用，這是一種特殊情況；_IsPlaceholder指示它是否是一個占位符，占位符需要替換，這也是一種特殊情況，后兩個引數用于偏特化，別處使用時只寫第一個引數，

_Mu<T>::operator()有統一的介面：第一個引數是_CVArg型別的，滿足typename std::decay<_CVArg>::type等于_Arg，&&是通用參考，雖然_CVArg的型別是可以窮舉的，但是寫成模板就把左值、右值、const、volatile等情況一并處理掉了；第二個引數是_Tuple型別，是呼叫引數轉發組成的std::tuple，

至于operator()要做什么作業，就要分情況討論了：

  • 第一種情況，當_Arg匹配到reference_wrapper<_Tp>時，operator()要做的僅僅是把reference_wrapper包裝的參考拿出來，

  • 第二種情況，_Arg是bind運算式，把std::tuple展開后給它呼叫，

    展開程序挺有意思的，假設sizeof...(_Args) == 3，型別_Indexes就是_Index_tuple<0, 1, 2>（這可以用模板元編程來實作），__call的模板引數_Indexes是0, 1, 2，對__arg的呼叫展開為：__arg(std::get<0>(std::move(__tuple)), std::get<1>(std::move(__tuple)), std::get<2>(std::move(__tuple)))，3個引數的型別分別是（std::decay后）_Tuple的第0、1、2個模板引數，剛好就是呼叫引數的型別，與介面相符，

    注意_Arg是_Bind或_Bind_result的一個實體，這里只是去呼叫bind運算式，沒有深入到里面的嵌套bind運算式和占位符替換（禁止套娃），

  • 第三種情況，_Arg是占位符，就回傳呼叫引數中對應的那個，占位符從1開始編號，std::tuple從0開始編號，所以要減去1，當占位符超過呼叫引數數量時，比如系結引數有_3而呼叫引數只有2個，std::get會報錯（但是我沒理解_Safe_tuple_element_t的意義），

  • 第四種情況，_Arg啥都匹配不上，它就是一個普普通通的值，直接轉發它即可，

_Bind

  /// Type of the function object returned from bind().
  template<typename _Signature>
    struct _Bind;

   template<typename _Functor, typename... _Bound_args>
    class _Bind<_Functor(_Bound_args...)>
    : public _Weak_result_type<_Functor>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
        _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;

      // Call unqualified
      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
        {
          return std::__invoke(_M_f,
              _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
              );
        }

      // Call as const
      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
        {
          return std::__invoke(_M_f,
              _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
              );
        }

      // Call as volatile
      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_v(tuple<_Args...>&& __args,
                 _Index_tuple<_Indexes...>) volatile
        {
          return std::__invoke(_M_f,
              _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
              );
        }

      // Call as const volatile
      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_c_v(tuple<_Args...>&& __args,
                   _Index_tuple<_Indexes...>) const volatile
        {
          return std::__invoke(_M_f,
              _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
              );
        }

      template<typename _BoundArg, typename _CallArgs>
        using _Mu_type = decltype(
            _Mu<typename remove_cv<_BoundArg>::type>()(
              std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );

      template<typename _Fn, typename _CallArgs, typename... _BArgs>
        using _Res_type_impl
          = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;

      template<typename _CallArgs>
        using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;

      template<typename _CallArgs>
        using __dependent = typename
          enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;

      template<typename _CallArgs, template<class> class __cv_quals>
        using _Res_type_cv = _Res_type_impl<
          typename __cv_quals<__dependent<_CallArgs>>::type,
          _CallArgs,
          typename __cv_quals<_Bound_args>::type...>;

     public:
      template<typename... _Args>
        explicit _Bind(const _Functor& __f, _Args&&... __args)
        : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
        { }

      template<typename... _Args>
        explicit _Bind(_Functor&& __f, _Args&&... __args)
        : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
        { }

      _Bind(const _Bind&) = default;

      _Bind(_Bind&& __b)
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
      { }

      // Call unqualified
      template<typename... _Args,
               typename _Result = _Res_type<tuple<_Args...>>>
        _Result
        operator()(_Args&&... __args)
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as const
      template<typename... _Args,
               typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
        _Result
        operator()(_Args&&... __args) const
        {
          return this->__call_c<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

#if __cplusplus > 201402L
# define _GLIBCXX_DEPR_BIND \
      [[deprecated("std::bind does not support volatile in C++17")]]
#else
# define _GLIBCXX_DEPR_BIND
#endif
      // Call as volatile
      template<typename... _Args,
               typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
        _GLIBCXX_DEPR_BIND
        _Result
        operator()(_Args&&... __args) volatile
        {
          return this->__call_v<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as const volatile
      template<typename... _Args,
               typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
        _GLIBCXX_DEPR_BIND
        _Result
        operator()(_Args&&... __args) const volatile
        {
          return this->__call_c_v<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }
    };

  /// Type of the function object returned from bind<R>().
  template<typename _Result, typename _Signature>
    struct _Bind_result;

  template<typename _Result, typename _Functor, typename... _Bound_args>
    class _Bind_result<_Result, _Functor(_Bound_args...)>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
        _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;

      // sfinae types
      template<typename _Res>
        using __enable_if_void
          = typename enable_if<is_void<_Res>{}>::type;

      template<typename _Res>
        using __disable_if_void
          = typename enable_if<!is_void<_Res>{}, _Result>::type;

      // Call unqualified
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __disable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
        {
          return std::__invoke(_M_f, _Mu<_Bound_args>()
                      (std::get<_Indexes>(_M_bound_args), __args)...);
        }

      // Call unqualified, return void
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __enable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
        {
          std::__invoke(_M_f, _Mu<_Bound_args>()
               (std::get<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as const
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __disable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
        {
          return std::__invoke(_M_f, _Mu<_Bound_args>()
                      (std::get<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as const, return void
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __enable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
        {
          std::__invoke(_M_f, _Mu<_Bound_args>()
               (std::get<_Indexes>(_M_bound_args),  __args)...);
        }

      // Call as volatile
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __disable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
        {
          return std::__invoke(_M_f, _Mu<_Bound_args>()
                      (__volget<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as volatile, return void
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __enable_if_void<_Res>
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
        {
          std::__invoke(_M_f, _Mu<_Bound_args>()
               (__volget<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as const volatile
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __disable_if_void<_Res>
        __call(tuple<_Args...>&& __args,
               _Index_tuple<_Indexes...>) const volatile
        {
          return std::__invoke(_M_f, _Mu<_Bound_args>()
                      (__volget<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as const volatile, return void
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        __enable_if_void<_Res>
        __call(tuple<_Args...>&& __args,
               _Index_tuple<_Indexes...>) const volatile
        {
          std::__invoke(_M_f, _Mu<_Bound_args>()
               (__volget<_Indexes>(_M_bound_args), __args)...);
        }

    public:
      typedef _Result result_type;

      template<typename... _Args>
        explicit _Bind_result(const _Functor& __f, _Args&&... __args)
        : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
        { }

      template<typename... _Args>
        explicit _Bind_result(_Functor&& __f, _Args&&... __args)
        : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
        { }

      _Bind_result(const _Bind_result&) = default;

      _Bind_result(_Bind_result&& __b)
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
      { }

      // Call unqualified
      template<typename... _Args>
        result_type
        operator()(_Args&&... __args)
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as const
      template<typename... _Args>
        result_type
        operator()(_Args&&... __args) const
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as volatile
      template<typename... _Args>
        _GLIBCXX_DEPR_BIND
        result_type
        operator()(_Args&&... __args) volatile
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as const volatile
      template<typename... _Args>
        _GLIBCXX_DEPR_BIND
        result_type
        operator()(_Args&&... __args) const volatile
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }
    };
#undef _GLIBCXX_DEPR_BIND

這一段就開始啰嗦了，但也沒有辦法，const加倍，volatile超級加倍，有些地方還要考慮&、&&和noexcept，以至于不得不用宏來定義，還好C++只有這幾個修飾符，

回到正題，_Bind包含兩個成員，可呼叫物件和系結的引數，后者包在一個std::tuple中保存，建構式把可呼叫物件拷貝或移動進來，系結引數轉發進來保存，_Bind類支持拷貝和移動，行為都是默認的，

_Bound_indexes與_Mu<_Arg, true, false>中的_Indexes相同，__call中的呼叫也與_Mu<_Arg, true, false>::operator()類似，不過不是用括號呼叫，而是用std::invoke，這把函式物件和成員指標等不同呼叫格式統一了起來，

有或沒有cv修飾符的__call和operator()大體上相同，無非是引數和回傳型別有些許區別，為了方便表示這些大同小異的型別，_Bind類中定義了一些工具：

  • _Mu_type把系結引數型別轉換為實際引數型別；

  • _Res_type_impl定義回傳型別，在不指定回傳型別的std::bind中，回傳型別是自動推導的；

  • _Res_type定義可呼叫物件沒有加cv修飾符時的回傳型別；

  • _Res_type_cv定義可呼叫物件加了cv修飾符時的回傳型別，cv修飾符共有3種組合，_Res_type_cv用模板引數__cv_quals來區分，模板里套模板，嗯，有內味了！我第一次見到這種操作時，跟當初學函式指標時一樣激動——等等，__cv_quals不也是函式一樣的東西作為引數嗎？

定義好了這些型別，4種__call和operator()就很容易實作了，這在_Mu的bind運算式的情況中已經分析過了，

_Bind_result略有不同，既然回傳型別已經規定好了，就不用各種定義了，但是又多出對void的討論，在回傳型別為void的函式中，你可以回傳一個回傳型別為void的運算式（但是不能直接return void;），但是你不能回傳一個非void運算式，因此std::bind<void>是一種特殊情況，_Bind_result對_Result為void需要專門的處理，

__enable_if_void和__disable_if_void分別在_Res是和不是void的時候有意義，每種__call函式都有兩個，回傳__disable_if_void<_Res>的有return陳述句，另一個沒有，對于特定的_Result，兩個函式中總是恰好有一個合法，根據SFINAE，另一個被忽略，void的情況就是這么處理的，

輔助

  template<typename _Func, typename... _BoundArgs>
    struct _Bind_check_arity { };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Tp, typename _Class, typename... _BoundArgs>
    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
    {
      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
      static_assert(_Varargs::value
                    ? sizeof...(_BoundArgs) >= _Arity::value + 1
                    : sizeof...(_BoundArgs) == _Arity::value + 1,
                    "Wrong number of arguments for pointer-to-member");
    };



  // Trait type used to remove std::bind() from overload set via SFINAE
  // when first argument has integer type, so that std::bind() will
  // not be a better match than ::bind() from the BSD Sockets API.
  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;

  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
    struct _Bind_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __func_type;
      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
    };

  // Partial specialization for is_socketlike == true, does not define
  // nested type so std::bind() will not participate in overload resolution
  // when the first argument might be a socket file descriptor.
  template<typename _Func, typename... _BoundArgs>
    struct _Bind_helper<true, _Func, _BoundArgs...>
    { };



  template<typename _Result, typename _Func, typename... _BoundArgs>
    struct _Bindres_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __functor_type;
      typedef _Bind_result<_Result,
                           __functor_type(typename decay<_BoundArgs>::type...)>
        type;
    };

_Bind_check_arity檢查引數數量：當可呼叫物件是函式或類成員時，可以檢查系結引數與可呼叫物件需要的引數是否匹配；如果函式是變參的，系結引數數量得大于等于函式引數數量；如果是類成員，還要加上1作為this指標，_Bind_helper繼承_Bind_check_arity，實體化時會檢查引數數量，如果錯誤的話編譯器會輸出static_assert錯誤，這樣比較好看，（你敢直面模板錯誤嗎？）

__is_socketlike用于消除多載：BSD套接字API中有::bind函式，其第一個引數是整型或列舉，不可能是可呼叫物件，當_Bind_helper的第一個模板引數為true時，類中沒有定義type型別，根據SFINAE，bind呼叫匹配到::bind，

bind

  /**
   *  @brief Function template for std::bind.
   *  @ingroup binders
   */
  template<typename _Func, typename... _BoundArgs>
    inline typename
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
                                          std::forward<_BoundArgs>(__args)...);
    }

  /**
   *  @brief Function template for std::bind<R>.
   *  @ingroup binders
   */
  template<typename _Result, typename _Func, typename... _BoundArgs>
    inline
    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
                                          std::forward<_BoundArgs>(__args)...);
    }

把可呼叫物件轉發進_Bind或_Bind_result并回傳，這就是std::bind的作業，

展望

  1. 對C++的展望：lambda、std::function、std::bind都是C++用以支持函式式范式的工具，而對資料的函式式處理，還需借由Boost.Range或在C++20中標準化的namespace std::ranges來完成，

  2. 對本文的展望：

    • 正如前言所述，std::tuple的實作是std::bind的實作中的主體，我應該再開一篇來講std::tuple的原理；

    • 對于一個想深入了解std::bind的讀者來說，帶著他欣賞原始碼可能不如手把手寫一遍來得有效，我實作過、擴展過std::function，可惜C++模板學藝不精，眼下還不能把實作中的每個細節都講明白，很巧的是就在剛才，學校里的老師問我要刪減的論文，被刪減的附錄中就包括一個std::function的擴展，等有機會再寫吧，

  3. 對我的展望：學模板、學FP，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/42994.html

標籤：C++

上一篇：無法正確通過演算法題目都是哪些原因造成的？

下一篇：STL之string

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂