剖析std::function接口與實現

 <functional> 系列

目錄

前言

一、std::function的原理與接口

　　1.1 std::function是函數包裝器

　　1.2 C++注重運行時效率

　　1.3 用函數指針實現多態

　　1.4 std::function的接口

二、std::function的實現

2.1 類型系統

2.1.1 異常類

2.1.2 數據存儲

2.1.3 輔助類

2.1.4 內存管理基類

2.1.5 仿函數調用

2.1.6 接口定義

2.1.7 類型關系

2.2 方法的功能與實現

2.2.1 多態性的體現

2.2.2 本地函數對象

2.2.3 heap函數對象

2.2.4 兩種存儲結構如何統一

2.2.5 根據形式區分仿函數類型

2.2.6 實現組裝成接口

后記

附錄

 

前言

為什么要剖析 std::function 呢？因為筆者最近在做一個 std::function 向單片機系統的移植與擴展。

后續還會有 std::bind 等標准庫其他部分的移植。

 

一、std::function的原理與接口

1.1 std::function是函數包裝器

std::function ，能存儲任何符合模板參數的函數對象。換句話說，這些擁有一致參數類型、相同返回值類型（其實不必完全相同）的函數對象，可以由 std::function 統一包裝起來。函數對象的大小是任意的、不能確定的，而C++中的類型都是固定大小的，那么，如何在一個固定大小的類型中存儲任意大小的對象呢？

實際上問題還不止存儲那么簡單。存儲了函數對象，必定是要在某一時刻調用；函數對象不是在創建的時候調用，這個特性成為延遲調用；函數對象也是對象，需要處理好構造、拷貝、移動、析構等問題——這些也需要延遲調用，但總不能再用 std::function 來解決吧？

既然 std::function 能存儲不同類型的函數對象，可以說它具有多態性。C++中體現多態性的主要是虛函數，繼承與多態這一套體制是可以解決這個問題的。相關資料[1] [2]中的實現利用了繼承與多態，相當簡潔。

 

1.2 C++注重運行時效率

利用繼承與多態，我們可以讓編譯器幫我們搞定函數對象的析構。就這種實現而言，這是簡潔而有效的方法。然而這種實現需要動態內存，在一些情況下不划算，甚至完全沒有必要。C++11引入了lambda表達式，其本質也是函數對象。這個對象有多大呢？取決於捕獲列表。你寫lambda會捕獲多少東西？很多情況下就只是一對方括號而已吧。在這種情況下，lambda表達式的對象大小只有1字節（因為不能是0字節），你卻為了這沒有內容的1字節要調用動態內存的函數？C++注重運行時效率，這種浪費是不能接受的。

如何避免這種浪費呢？你也許會說我檢查傳入的對象是不是1字節的空類型。且不論這個trait怎么實現，函數指針、捕獲一個int的lambda等類型都聲稱自己是trivial的小對象，也不應該分配到heap中去。

之前說過，std::function 的大小是固定的，但是這個大小是可以自己定的。我們可以在 std::function 的類定義中加入一個空白的、大小適中的field，用在存放這些小對象，從而避免這些情況下的動態內存操作。同時，既然有了這片空間，也就不需要看傳入的對象是不是1字節的空類型了。

而對於更大的類型，雖然這個field不足以存放函數對象，但足以存放一個指針，這種分時復用的結構可以用union來實現。這種小對象直接存儲、大對象在heap上開辟空間並存儲指針的方法，稱為small object optimization。

在利用繼承的實現中，函數對象被包裝在一個子類中，std::function 中持有一個其父類的指針。然而為了效率，我們需要把空白field和這個指針union起來。union總給人一種底層的感覺，在不確定這個union到底存儲的是什么的時候，當然不能通過其中的指針去調用虛函數。在這樣的設計中，多態性不再能用繼承體系實現了，我們需要另一種實現多態的方法。

 

1.3 用函數指針實現多態

回想一下虛函數是如何實現的？帶有virtual function的類的對象中會安插vptr，這個指針指向一個vtable，這個vtable含有多個slot，里面含有指向type_info對象的指針與函數指針——對，我們需要函數指針！不知你有沒有在C中實現過多態，在沒有語言特性的幫助下，比較方便的方法是在struct中直接放函數指針。如果要像C++那樣用上vptr和vtable，你得管理好每個類及其對應vtable的內容。你以為這種情況在C++中就有所好轉嗎？只有你用C++的繼承體系，編譯器才會幫你做這些事。想要自己建立一個從類型到vptr的映射，恐怕你得改編譯器了。（更正：C++14引入了變量模板，請移步C++值多態：傳統多態與類型擦除之間。）

vptr與vtable的意義是什么？其一，每個基類只對應一個vptr，大小固定，多重繼承下便於管理，但這點與這篇文章的主題沒有關聯；其二，當基類有多個虛函數的時候，使用vptr可以節省存儲對象的空間，而如果用函數指針的話，雖然少了一次尋址，但繼承帶來的空間overhead取決於虛函數的數量，由於至少一個，函數指針的占用的空間不會少於vptr，在虛函數數量較多的情況下，函數指針就要占用比較大的空間了。

既然我們已經無法在 std::function 中使用vptr，我們也應該盡可能減少函數指針的數量，而這又取決於這些函數的功能，進一步取決於 std::function 類的接口。

 

1.4 std::function的接口

雖然C++標准規定了 std::function 的接口就應該是這樣，我還是想說說它為什么應該是這樣。關於其他的一些問題，比如保存值還是保存引用等，可以參考相關資料[4]。

最基本的，std::function 是一個模板類，模板參數是一個類型（注意是一個類型，不是好幾個類型）。我們可以這么寫：

std::function<int(double)> f;

f 是一個可調用對象，參數為 double，返回值為 int 。你也許會問，這里既規定了參數類型又規定了返回值類型，怎么就成了一個類型呢？確實是一個類型，int(double) 是一個函數類型（注意不是函數指針）。

std::function 要包裝所有合適類型的對象，就必須有對應的構造函數，所以這是個模板構造函數。參數不是通用引用而是直接傳值：

template <typename F>
function(F);

可能是為了讓編譯器對空對象進行優化。同樣還有一個模板賦值函數，參數是通用引用。

每個構造函數都有一個添加了 std::allocator_arg_t 作為第一個參數、內存分配器對象作為第二個參數的版本，C++17中已經移除（GCC從未提供，可能是因為 std::function 的內存分配無法自定義）。同樣刪除的還有 assign ，也是與內存分配器相關的。

另外有一個以 std::reference_wrapper 作為參數的賦值函數：

template <typename F>
function& operator=(std::reference_wrapper<F>) noexcept;

可以理解為模板賦值函數的特化。沒有相應的構造函數。

默認構造函數、nullptr_t 構造函數、nullptr_t 拷貝賦值函數都將 std::function 對象置空。當 std::function 對象沒有保存任何函數對象時， operator bool() 返回 false ，與 nullptr_t 調用 operator== 會返回 true ，如果調用將拋出 std::bad_function_call 異常。

雖然 std::function 將函數對象包裝了起來，但用戶還是可以獲得原始對象的。target_type() 返回函數對象的 typeid ，target() 模板函數當模板參數與函數對象類型相同時返回其指針，否則返回空指針。

作為函數包裝器，std::function 也是函數對象，可以通過 operator() 調用，參數按照模板參數中聲明的類型傳遞。

還有一些接口與大部分STL設施相似，有Rule of Five規定的5個方法、 swap() ，以及 std::swap() 的特化等。可別小看這個 swap() ，它有大用處。

總之，函數對象的復制、移動、賦值、交換等操作都是需要的。對客戶來說，除了兩個 std::function 的相等性判定（筆者最近在嘗試實現這個）以外，其他能想到的方法它都有。

 

二、std::function的實現

std::function 的實現位於 <functional> ，后續版本遷移至了 <bits/std_function.h> 。下面這段代碼是GCC 4.8.1（第一個支持完整C++11的版本）中的 <functional> 頭文件，共2579行，默認折疊，慎入。

// <functional> -*- C++ -*-

// Copyright (C) 2001-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/*
 * Copyright (c) 1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

/** @file include/functional
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_FUNCTIONAL
#define _GLIBCXX_FUNCTIONAL 1

#pragma GCC system_header

#include <bits/c++config.h>
#include <bits/stl_function.h>

#if __cplusplus >= 201103L

#include <typeinfo>
#include <new>
#include <tuple>
#include <type_traits>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _MemberPointer>
    class _Mem_fn;
  template<typename _Tp, typename _Class>
    _Mem_fn<_Tp _Class::*>
    mem_fn(_Tp _Class::*) noexcept;

_GLIBCXX_HAS_NESTED_TYPE(result_type)

  /// If we have found a result_type, extract it.
  template<bool _Has_result_type, typename _Functor>
    struct _Maybe_get_result_type
    { };

  template<typename _Functor>
    struct _Maybe_get_result_type<true, _Functor>
    { typedef typename _Functor::result_type result_type; };

  /**
   *  Base class for any function object that has a weak result type, as
   *  defined in 3.3/3 of TR1.
  */
  template<typename _Functor>
    struct _Weak_result_type_impl
    : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
    { };

  /// Retrieve the result type for a function type.
  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes......)>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
    { typedef _Res result_type; };

  /// Retrieve the result type for a function reference.
  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
    { typedef _Res result_type; };

  /// Retrieve the result type for a function pointer.
  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
    { typedef _Res result_type; };

  template<typename _Res, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
    { typedef _Res result_type; };

  /// Retrieve result type for a member function pointer.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
    { typedef _Res result_type; };

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
    { typedef _Res result_type; };

  /// Retrieve result type for a const member function pointer.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
    { typedef _Res result_type; };

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
    { typedef _Res result_type; };

  /// Retrieve result type for a volatile member function pointer.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
    { typedef _Res result_type; };

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
    { typedef _Res result_type; };

  /// Retrieve result type for a const volatile member function pointer.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
                                  const volatile>
    { typedef _Res result_type; };

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
                                  const volatile>
    { typedef _Res result_type; };

  /**
   *  Strip top-level cv-qualifiers from the function object and let
   *  _Weak_result_type_impl perform the real work.
  */
  template<typename _Functor>
    struct _Weak_result_type
    : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
    { };

  /// Determines if the type _Tp derives from unary_function.
  template<typename _Tp>
    struct _Derives_from_unary_function : __sfinae_types
    {
    private:
      template<typename _T1, typename _Res>
        static __one __test(const volatile unary_function<_T1, _Res>*);

      // It's tempting to change "..." to const volatile void*, but
      // that fails when _Tp is a function type.
      static __two __test(...);

    public:
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
    };

  /// Determines if the type _Tp derives from binary_function.
  template<typename _Tp>
    struct _Derives_from_binary_function : __sfinae_types
    {
    private:
      template<typename _T1, typename _T2, typename _Res>
        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);

      // It's tempting to change "..." to const volatile void*, but
      // that fails when _Tp is a function type.
      static __two __test(...);

    public:
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
    };

  /**
   * Invoke a function object, which may be either a member pointer or a
   * function object. The first parameter will tell which.
   */
  template<typename _Functor, typename... _Args>
    inline
    typename enable_if<
             (!is_member_pointer<_Functor>::value
              && !is_function<_Functor>::value
              && !is_function<typename remove_pointer<_Functor>::type>::value),
             typename result_of<_Functor&(_Args&&...)>::type
           >::type
    __invoke(_Functor& __f, _Args&&... __args)
    {
      return __f(std::forward<_Args>(__args)...);
    }

  template<typename _Functor, typename... _Args>
    inline
    typename enable_if<
             (is_member_pointer<_Functor>::value
              && !is_function<_Functor>::value
              && !is_function<typename remove_pointer<_Functor>::type>::value),
             typename result_of<_Functor(_Args&&...)>::type
           >::type
    __invoke(_Functor& __f, _Args&&... __args)
    {
      return std::mem_fn(__f)(std::forward<_Args>(__args)...);
    }

  // To pick up function references (that will become function pointers)
  template<typename _Functor, typename... _Args>
    inline
    typename enable_if<
             (is_pointer<_Functor>::value
              && is_function<typename remove_pointer<_Functor>::type>::value),
             typename result_of<_Functor(_Args&&...)>::type
           >::type
    __invoke(_Functor __f, _Args&&... __args)
    {
      return __f(std::forward<_Args>(__args)...);
    }

  /**
   *  Knowing which of unary_function and binary_function _Tp derives
   *  from, derives from the same and ensures that reference_wrapper
   *  will have a weak result type. See cases below.
   */
  template<bool _Unary, bool _Binary, typename _Tp>
    struct _Reference_wrapper_base_impl;

  // None of the nested argument types.
  template<typename _Tp>
    struct _Reference_wrapper_base_impl<false, false, _Tp>
    : _Weak_result_type<_Tp>
    { };

  // Nested argument_type only.
  template<typename _Tp>
    struct _Reference_wrapper_base_impl<true, false, _Tp>
    : _Weak_result_type<_Tp>
    {
      typedef typename _Tp::argument_type argument_type;
    };

  // Nested first_argument_type and second_argument_type only.
  template<typename _Tp>
    struct _Reference_wrapper_base_impl<false, true, _Tp>
    : _Weak_result_type<_Tp>
    {
      typedef typename _Tp::first_argument_type first_argument_type;
      typedef typename _Tp::second_argument_type second_argument_type;
    };

  // All the nested argument types.
   template<typename _Tp>
    struct _Reference_wrapper_base_impl<true, true, _Tp>
    : _Weak_result_type<_Tp>
    {
      typedef typename _Tp::argument_type argument_type;
      typedef typename _Tp::first_argument_type first_argument_type;
      typedef typename _Tp::second_argument_type second_argument_type;
    };

  _GLIBCXX_HAS_NESTED_TYPE(argument_type)
  _GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
  _GLIBCXX_HAS_NESTED_TYPE(second_argument_type)

  /**
   *  Derives from unary_function or binary_function when it
   *  can. Specializations handle all of the easy cases. The primary
   *  template determines what to do with a class type, which may
   *  derive from both unary_function and binary_function.
  */
  template<typename _Tp>
    struct _Reference_wrapper_base
    : _Reference_wrapper_base_impl<
      __has_argument_type<_Tp>::value,
      __has_first_argument_type<_Tp>::value
      && __has_second_argument_type<_Tp>::value,
      _Tp>
    { };

  // - a function type (unary)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1)>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) volatile>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const volatile>
    : unary_function<_T1, _Res>
    { };

  // - a function type (binary)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2)>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
    : binary_function<_T1, _T2, _Res>
    { };

  // - a function pointer type (unary)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(*)(_T1)>
    : unary_function<_T1, _Res>
    { };

  // - a function pointer type (binary)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
    : binary_function<_T1, _T2, _Res>
    { };

  // - a pointer to member function type (unary, no qualifiers)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)()>
    : unary_function<_T1*, _Res>
    { };

  // - a pointer to member function type (binary, no qualifiers)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
    : binary_function<_T1*, _T2, _Res>
    { };

  // - a pointer to member function type (unary, const)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() const>
    : unary_function<const _T1*, _Res>
    { };

  // - a pointer to member function type (binary, const)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
    : binary_function<const _T1*, _T2, _Res>
    { };

  // - a pointer to member function type (unary, volatile)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
    : unary_function<volatile _T1*, _Res>
    { };

  // - a pointer to member function type (binary, volatile)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
    : binary_function<volatile _T1*, _T2, _Res>
    { };

  // - a pointer to member function type (unary, const volatile)
  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
    : unary_function<const volatile _T1*, _Res>
    { };

  // - a pointer to member function type (binary, const volatile)
  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
    : binary_function<const volatile _T1*, _T2, _Res>
    { };

  /**
   *  @brief Primary class template for reference_wrapper.
   *  @ingroup functors
   *  @{
   */
  template<typename _Tp>
    class reference_wrapper
    : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
    {
      _Tp* _M_data;

    public:
      typedef _Tp type;

      reference_wrapper(_Tp& __indata) noexcept
      : _M_data(std::__addressof(__indata))
      { }

      reference_wrapper(_Tp&&) = delete;

      reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
      : _M_data(__inref._M_data)
      { }

      reference_wrapper&
      operator=(const reference_wrapper<_Tp>& __inref) noexcept
      {
        _M_data = __inref._M_data;
        return *this;
      }

      operator _Tp&() const noexcept
      { return this->get(); }

      _Tp&
      get() const noexcept
      { return *_M_data; }

      template<typename... _Args>
        typename result_of<_Tp&(_Args&&...)>::type
        operator()(_Args&&... __args) const
        {
          return __invoke(get(), std::forward<_Args>(__args)...);
        }
    };


  /// Denotes a reference should be taken to a variable.
  template<typename _Tp>
    inline reference_wrapper<_Tp>
    ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }

  /// Denotes a const reference should be taken to a variable.
  template<typename _Tp>
    inline reference_wrapper<const _Tp>
    cref(const _Tp& __t) noexcept
    { return reference_wrapper<const _Tp>(__t); }

  template<typename _Tp>
    void ref(const _Tp&&) = delete;

  template<typename _Tp>
    void cref(const _Tp&&) = delete;

  /// Partial specialization.
  template<typename _Tp>
    inline reference_wrapper<_Tp>
    ref(reference_wrapper<_Tp> __t) noexcept
    { return ref(__t.get()); }

  /// Partial specialization.
  template<typename _Tp>
    inline reference_wrapper<const _Tp>
    cref(reference_wrapper<_Tp> __t) noexcept
    { return cref(__t.get()); }

  // @} group functors

  template<typename... _Types>
    struct _Pack : integral_constant<size_t, sizeof...(_Types)>
    { };

  template<typename _From, typename _To, bool = _From::value == _To::value>
    struct _AllConvertible : false_type
    { };

  template<typename... _From, typename... _To>
    struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
    : __and_<is_convertible<_From, _To>...>
    { };

  template<typename _Tp1, typename _Tp2>
    using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
                                    typename std::decay<_Tp2>::type>>;

  /**
   * Derives from @c unary_function or @c binary_function, or perhaps
   * nothing, depending on the number of arguments provided. The
   * primary template is the basis case, which derives nothing.
   */
  template<typename _Res, typename... _ArgTypes>
    struct _Maybe_unary_or_binary_function { };

  /// Derives from @c unary_function, as appropriate.
  template<typename _Res, typename _T1>
    struct _Maybe_unary_or_binary_function<_Res, _T1>
    : std::unary_function<_T1, _Res> { };

  /// Derives from @c binary_function, as appropriate.
  template<typename _Res, typename _T1, typename _T2>
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
    : std::binary_function<_T1, _T2, _Res> { };

  /// Implementation of @c mem_fn for member function pointers.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...);

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __object, const volatile _Class *,
                _Args&&... __args) const
        {
          return (std::forward<_Tp>(__object).*__pmf)
            (std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
        { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }

      // Require each _Args to be convertible to corresponding _ArgTypes
      template<typename... _Args>
        using _RequireValidArgs
          = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      // Require each _Args to be convertible to corresponding _ArgTypes
      // and require _Tp is not _Class, _Class& or _Class*
      template<typename _Tp, typename... _Args>
        using _RequireValidArgs2
          = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      // Require each _Args to be convertible to corresponding _ArgTypes
      // and require _Tp is _Class or derived from _Class
      template<typename _Tp, typename... _Args>
        using _RequireValidArgs3
          = _Require<is_base_of<_Class, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(_Class& __object, _Args&&... __args) const
        { return (__object.*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(_Class&& __object, _Args&&... __args) const
        {
          return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
        }

      // Handle pointers
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(_Class* __object, _Args&&... __args) const
        { return (__object->*__pmf)(std::forward<_Args>(__args)...); }

      // Handle smart pointers, references and pointers to derived
      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs2<_Tp, _Args...>>
        _Res
        operator()(_Tp&& __object, _Args&&... __args) const
        {
          return _M_call(std::forward<_Tp>(__object), &__object,
              std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs3<_Tp, _Args...>>
        _Res
        operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
        { return operator()(__ref.get(), std::forward<_Args>(__args)...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for const member function pointers.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
    : public _Maybe_unary_or_binary_function<_Res, const _Class*,
                                             _ArgTypes...>
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __object, const volatile _Class *,
                _Args&&... __args) const
        {
          return (std::forward<_Tp>(__object).*__pmf)
            (std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
        { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args>
        using _RequireValidArgs
          = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs2
          = _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs3
          = _Require<is_base_of<_Class, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const _Class& __object, _Args&&... __args) const
        { return (__object.*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const _Class&& __object, _Args&&... __args) const
        {
          return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
        }

      // Handle pointers
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const _Class* __object, _Args&&... __args) const
        { return (__object->*__pmf)(std::forward<_Args>(__args)...); }

      // Handle smart pointers, references and pointers to derived
      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs2<_Tp, _Args...>>
        _Res operator()(_Tp&& __object, _Args&&... __args) const
        {
          return _M_call(std::forward<_Tp>(__object), &__object,
              std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs3<_Tp, _Args...>>
        _Res
        operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
        { return operator()(__ref.get(), std::forward<_Args>(__args)...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for volatile member function pointers.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
                                             _ArgTypes...>
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __object, const volatile _Class *,
                _Args&&... __args) const
        {
          return (std::forward<_Tp>(__object).*__pmf)
            (std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
        { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args>
        using _RequireValidArgs
          = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs2
          = _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs3
          = _Require<is_base_of<_Class, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(volatile _Class& __object, _Args&&... __args) const
        { return (__object.*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(volatile _Class&& __object, _Args&&... __args) const
        {
          return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
        }

      // Handle pointers
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(volatile _Class* __object, _Args&&... __args) const
        { return (__object->*__pmf)(std::forward<_Args>(__args)...); }

      // Handle smart pointers, references and pointers to derived
      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs2<_Tp, _Args...>>
        _Res
        operator()(_Tp&& __object, _Args&&... __args) const
        {
          return _M_call(std::forward<_Tp>(__object), &__object,
              std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs3<_Tp, _Args...>>
        _Res
        operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
        { return operator()(__ref.get(), std::forward<_Args>(__args)...); }

    private:
      _Functor __pmf;
    };

  /// Implementation of @c mem_fn for const volatile member function pointers.
  template<typename _Res, typename _Class, typename... _ArgTypes>
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
                                             _ArgTypes...>
    {
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __object, const volatile _Class *,
                _Args&&... __args) const
        {
          return (std::forward<_Tp>(__object).*__pmf)
            (std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args>
        _Res
        _M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
        { return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args>
        using _RequireValidArgs
          = _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs2
          = _Require<_NotSame<_Class, _Tp>,
                     _NotSame<const volatile _Class*, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

      template<typename _Tp, typename... _Args>
        using _RequireValidArgs3
          = _Require<is_base_of<_Class, _Tp>,
                     _AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;

    public:
      typedef _Res result_type;

      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }

      // Handle objects
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const volatile _Class& __object, _Args&&... __args) const
        { return (__object.*__pmf)(std::forward<_Args>(__args)...); }

      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const volatile _Class&& __object, _Args&&... __args) const
        {
          return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
        }

      // Handle pointers
      template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
        _Res
        operator()(const volatile _Class* __object, _Args&&... __args) const
        { return (__object->*__pmf)(std::forward<_Args>(__args)...); }

      // Handle smart pointers, references and pointers to derived
      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs2<_Tp, _Args...>>
        _Res operator()(_Tp&& __object, _Args&&... __args) const
        {
          return _M_call(std::forward<_Tp>(__object), &__object,
              std::forward<_Args>(__args)...);
        }

      template<typename _Tp, typename... _Args,
               typename _Req = _RequireValidArgs3<_Tp, _Args...>>
        _Res
        operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
        { return operator()(__ref.get(), std::forward<_Args>(__args)...); }

    private:
      _Functor __pmf;
    };


  template<typename _Tp, bool>
    struct _Mem_fn_const_or_non
    {
      typedef const _Tp& type;
    };

  template<typename _Tp>
    struct _Mem_fn_const_or_non<_Tp, false>
    {
      typedef _Tp& type;
    };

  template<typename _Res, typename _Class>
    class _Mem_fn<_Res _Class::*>
    {
      using __pm_type = _Res _Class::*;

      // This bit of genius is due to Peter Dimov, improved slightly by
      // Douglas Gregor.
      // Made less elegant to support perfect forwarding and noexcept.
      template<typename _Tp>
        auto
        _M_call(_Tp&& __object, const _Class *) const noexcept
        -> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
        { return std::forward<_Tp>(__object).*__pm; }

      template<typename _Tp, typename _Up>
        auto
        _M_call(_Tp&& __object, _Up * const *) const noexcept
        -> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
        { return (*std::forward<_Tp>(__object)).*__pm; }

      template<typename _Tp>
        auto
        _M_call(_Tp&& __ptr, const volatile void*) const
        noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
        -> decltype((*__ptr).*std::declval<__pm_type&>())
        { return (*__ptr).*__pm; }

    public:
      explicit
      _Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }

      // Handle objects
      _Res&
      operator()(_Class& __object) const noexcept
      { return __object.*__pm; }

      const _Res&
      operator()(const _Class& __object) const noexcept
      { return __object.*__pm; }

      _Res&&
      operator()(_Class&& __object) const noexcept
      { return std::forward<_Class>(__object).*__pm; }

      const _Res&&
      operator()(const _Class&& __object) const noexcept
      { return std::forward<const _Class>(__object).*__pm; }

      // Handle pointers
      _Res&
      operator()(_Class* __object) const noexcept
      { return __object->*__pm; }

      const _Res&
      operator()(const _Class* __object) const noexcept
      { return __object->*__pm; }

      // Handle smart pointers and derived
      template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
        auto
        operator()(_Tp&& __unknown) const
        noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
                          (std::forward<_Tp>(__unknown), &__unknown)))
        -> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
        { return _M_call(std::forward<_Tp>(__unknown), &__unknown); }

      template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
        auto
        operator()(reference_wrapper<_Tp> __ref) const
        noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
        -> decltype((*this)(__ref.get()))
        { return (*this)(__ref.get()); }

    private:
      _Res _Class::*__pm;
    };

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2048.  Unnecessary mem_fn overloads
  /**
   *  @brief Returns a function object that forwards to the member
   *  pointer @a pm.
   *  @ingroup functors
   */
  template<typename _Tp, typename _Class>
    inline _Mem_fn<_Tp _Class::*>
    mem_fn(_Tp _Class::* __pm) noexcept
    {
      return _Mem_fn<_Tp _Class::*>(__pm);
    }

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

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

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

  _GLIBCXX_END_NAMESPACE_VERSION

  /** @namespace std::placeholders
   *  @brief ISO C++11 entities sub-namespace for functional.
   *  @ingroup binders
   */
  namespace placeholders
  {
  _GLIBCXX_BEGIN_NAMESPACE_VERSION
  /* 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;
  _GLIBCXX_END_NAMESPACE_VERSION
  }

  _GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  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>
    { };

  /**
   * Used by _Safe_tuple_element to indicate that there is no tuple
   * element at this position.
   */
  struct _No_tuple_element;

  /**
   * Implementation helper for _Safe_tuple_element. This primary
   * template handles the case where it is safe to use @c
   * tuple_element.
   */
  template<std::size_t __i, typename _Tuple, bool _IsSafe>
    struct _Safe_tuple_element_impl
    : tuple_element<__i, _Tuple> { };

  /**
   * Implementation helper for _Safe_tuple_element. This partial
   * specialization handles the case where it is not safe to use @c
   * tuple_element. We just return @c _No_tuple_element.
   */
  template<std::size_t __i, typename _Tuple>
    struct _Safe_tuple_element_impl<__i, _Tuple, false>
    {
      typedef _No_tuple_element type;
    };

  /**
   * Like tuple_element, but returns @c _No_tuple_element when
   * tuple_element would return an error.
   */
 template<std::size_t __i, typename _Tuple>
   struct _Safe_tuple_element
   : _Safe_tuple_element_impl<__i, _Tuple,
                              (__i < tuple_size<_Tuple>::value)>
   { };

  /**
   *  Maps an argument to bind() into an actual argument to the bound
   *  function object [TR1 3.6.3/5]. 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. [TR1 3.6.3/5 bullet 1]
   */
  template<typename _Tp>
    class _Mu<reference_wrapper<_Tp>, false, false>
    {
    public:
      typedef _Tp& result_type;

      /* 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>
        result_type
        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). [TR1 3.6.3/5 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::forward<_Args>(get<_Indexes>(__tuple))...);
        }
    };

  /**
   *  If the argument is a placeholder for the Nth argument, returns
   *  a reference to the Nth argument to the bind function object.
   *  [TR1 3.6.3/5 bullet 3]
   */
  template<typename _Arg>
    class _Mu<_Arg, false, true>
    {
    public:
      template<typename _Signature> class result;

      template<typename _CVMu, typename _CVArg, typename _Tuple>
        class result<_CVMu(_CVArg, _Tuple)>
        {
          // Add a reference, if it hasn't already been done for us.
          // This allows us to be a little bit sloppy in constructing
          // the tuple that we pass to result_of<...>.
          typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
                                                - 1), _Tuple>::type
            __base_type;

        public:
          typedef typename add_rvalue_reference<__base_type>::type type;
        };

      template<typename _Tuple>
        typename result<_Mu(_Arg, _Tuple)>::type
        operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
        {
          return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
              ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
        }
    };

  /**
   *  If the argument is just a value, returns a reference to that
   *  value. The cv-qualifiers on the reference are the same as the
   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
   */
  template<typename _Arg>
    class _Mu<_Arg, false, false>
    {
    public:
      template<typename _Signature> struct result;

      template<typename _CVMu, typename _CVArg, typename _Tuple>
        struct result<_CVMu(_CVArg, _Tuple)>
        {
          typedef typename add_lvalue_reference<_CVArg>::type type;
        };

      // Pick up the cv-qualifiers of the argument
      template<typename _CVArg, typename _Tuple>
        _CVArg&&
        operator()(_CVArg&& __arg, _Tuple&) const volatile
        { return std::forward<_CVArg>(__arg); }
    };

  /**
   *  Maps member pointers into instances of _Mem_fn but leaves all
   *  other function objects untouched. Used by tr1::bind(). The
   *  primary template handles the non--member-pointer case.
   */
  template<typename _Tp>
    struct _Maybe_wrap_member_pointer
    {
      typedef _Tp type;

      static const _Tp&
      __do_wrap(const _Tp& __x)
      { return __x; }

      static _Tp&&
      __do_wrap(_Tp&& __x)
      { return static_cast<_Tp&&>(__x); }
    };

  /**
   *  Maps member pointers into instances of _Mem_fn but leaves all
   *  other function objects untouched. Used by tr1::bind(). This
   *  partial specialization handles the member pointer case.
   */
  template<typename _Tp, typename _Class>
    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
    {
      typedef _Mem_fn<_Tp _Class::*> type;

      static type
      __do_wrap(_Tp _Class::* __pm)
      { return type(__pm); }
    };

  // Specialization needed to prevent "forming reference to void" errors when
  // bind<void>() is called, because argument deduction instantiates
  // _Maybe_wrap_member_pointer<void> outside the immediate context where
  // SFINAE applies.
  template<>
    struct _Maybe_wrap_member_pointer<void>
    {
      typedef void type;
    };

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

  /// 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 _Bind __self_type;
      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 _M_f(_Mu<_Bound_args>()
                      (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 _M_f(_Mu<_Bound_args>()
                      (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 _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 _M_f(_Mu<_Bound_args>()
                      (__volget<_Indexes>(_M_bound_args), __args)...);
        }

     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
        = decltype( std::declval<_Functor>()(
              _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
                                  std::declval<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
        = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
                       typename add_const<_Functor>::type>::type>()(
              _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
                                  std::declval<tuple<_Args...>&>() )... ) )>
        _Result
        operator()(_Args&&... __args) const
        {
          return this->__call_c<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }

      // Call as volatile
      template<typename... _Args, typename _Result
        = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
                       typename add_volatile<_Functor>::type>::type>()(
              _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
                                  std::declval<tuple<_Args...>&>() )... ) )>
        _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
        = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
                       typename add_cv<_Functor>::type>::type>()(
              _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
                                  std::declval<tuple<_Args...>&>() )... ) )>
        _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 _Bind_result __self_type;
      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>
        struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
      template<typename _Res>
        struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };

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

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

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

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

      // Call as volatile
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0) volatile
        {
          return _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>
        void
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __enable_if_void<_Res>::type = 0) volatile
        {
          _M_f(_Mu<_Bound_args>()
               (__volget<_Indexes>(_M_bound_args), __args)...);
        }

      // Call as const volatile
      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0) const volatile
        {
          return _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>
        void
        __call(tuple<_Args...>&& __args,
               _Index_tuple<_Indexes...>,
            typename __enable_if_void<_Res>::type = 0) const volatile
        {
          _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>
        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>
        result_type
        operator()(_Args&&... __args) const volatile
        {
          return this->__call<_Result>(
              std::forward_as_tuple(std::forward<_Args>(__args)...),
              _Bound_indexes());
        }
    };

  /**
   *  @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 { };

  // 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
    {
      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
        __maybe_type;
      typedef typename __maybe_type::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...>
    { };

  /**
   *  @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;
      typedef typename __helper_type::__maybe_type __maybe_type;
      typedef typename __helper_type::type __result_type;
      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
                           std::forward<_BoundArgs>(__args)...);
    }

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

  /**
   *  @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;
      typedef typename __helper_type::__maybe_type __maybe_type;
      typedef typename __helper_type::type __result_type;
      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
                           std::forward<_BoundArgs>(__args)...);
    }

  template<typename _Signature>
    struct _Bind_simple;

  template<typename _Callable, typename... _Args>
    struct _Bind_simple<_Callable(_Args...)>
    {
      typedef typename result_of<_Callable(_Args...)>::type result_type;

      template<typename... _Args2, typename = typename
               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
        explicit
        _Bind_simple(const _Callable& __callable, _Args2&&... __args)
        : _M_bound(__callable, std::forward<_Args2>(__args)...)
        { }

      template<typename... _Args2, typename = typename
               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
        explicit
        _Bind_simple(_Callable&& __callable, _Args2&&... __args)
        : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
        { }

      _Bind_simple(const _Bind_simple&) = default;
      _Bind_simple(_Bind_simple&&) = default;

      result_type
      operator()()
      {
        typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
        return _M_invoke(_Indices());
      }

    private:

      template<std::size_t... _Indices>
        typename result_of<_Callable(_Args...)>::type
        _M_invoke(_Index_tuple<_Indices...>)
        {
          // std::bind always forwards bound arguments as lvalues,
          // but this type can call functions which only accept rvalues.
          return std::forward<_Callable>(std::get<0>(_M_bound))(
              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
        }

      std::tuple<_Callable, _Args...> _M_bound;
    };

  template<typename _Func, typename... _BoundArgs>
    struct _Bind_simple_helper
    {
      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
        __maybe_type;
      typedef typename __maybe_type::type __func_type;
      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
               __type;
    };

  // Simplified version of std::bind for internal use, without support for
  // unbound arguments, placeholders or nested bind expressions.
  template<typename _Callable, typename... _Args>
    typename _Bind_simple_helper<_Callable, _Args...>::__type
    __bind_simple(_Callable&& __callable, _Args&&... __args)
    {
      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
      typedef typename __helper_type::__maybe_type __maybe_type;
      typedef typename __helper_type::__type __result_type;
      return __result_type(
          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
          std::forward<_Args>(__args)...);
    }

  /**
   *  @brief Exception class thrown when class template function's
   *  operator() is called with an empty target.
   *  @ingroup exceptions
   */
  class bad_function_call : public std::exception
  {
  public:
    virtual ~bad_function_call() noexcept;

    const char* what() const noexcept;
  };

  /**
   *  Trait identifying "location-invariant" types, meaning that the
   *  address of the object (or any of its members) will not escape.
   *  Also implies a trivial copy constructor and assignment operator.
   */
  template<typename _Tp>
    struct __is_location_invariant
    : integral_constant<bool, (is_pointer<_Tp>::value
                               || is_member_pointer<_Tp>::value)>
    { };

  class _Undefined_class;

  union _Nocopy_types
  {
    void*       _M_object;
    const void* _M_const_object;
    void (*_M_function_pointer)();
    void (_Undefined_class::*_M_member_pointer)();
  };

  union _Any_data
  {
    void*       _M_access()       { return &_M_pod_data[0]; }
    const void* _M_access() const { return &_M_pod_data[0]; }

    template<typename _Tp>
      _Tp&
      _M_access()
      { return *static_cast<_Tp*>(_M_access()); }

    template<typename _Tp>
      const _Tp&
      _M_access() const
      { return *static_cast<const _Tp*>(_M_access()); }

    _Nocopy_types _M_unused;
    char _M_pod_data[sizeof(_Nocopy_types)];
  };

  enum _Manager_operation
  {
    __get_type_info,
    __get_functor_ptr,
    __clone_functor,
    __destroy_functor
  };

  // Simple type wrapper that helps avoid annoying const problems
  // when casting between void pointers and pointers-to-pointers.
  template<typename _Tp>
    struct _Simple_type_wrapper
    {
      _Simple_type_wrapper(_Tp __value) : __value(__value) { }

      _Tp __value;
    };

  template<typename _Tp>
    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
    : __is_location_invariant<_Tp>
    { };

  // Converts a reference to a function object into a callable
  // function object.
  template<typename _Functor>
    inline _Functor&
    __callable_functor(_Functor& __f)
    { return __f; }

  template<typename _Member, typename _Class>
    inline _Mem_fn<_Member _Class::*>
    __callable_functor(_Member _Class::* &__p)
    { return std::mem_fn(__p); }

  template<typename _Member, typename _Class>
    inline _Mem_fn<_Member _Class::*>
    __callable_functor(_Member _Class::* const &__p)
    { return std::mem_fn(__p); }

  template<typename _Member, typename _Class>
    inline _Mem_fn<_Member _Class::*>
    __callable_functor(_Member _Class::* volatile &__p)
    { return std::mem_fn(__p); }

  template<typename _Member, typename _Class>
    inline _Mem_fn<_Member _Class::*>
    __callable_functor(_Member _Class::* const volatile &__p)
    { return std::mem_fn(__p); }

  template<typename _Signature>
    class function;

  /// Base class of all polymorphic function object wrappers.
  class _Function_base
  {
  public:
    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);

    template<typename _Functor>
      class _Base_manager
      {
      protected:
        static const bool __stored_locally =
        (__is_location_invariant<_Functor>::value
         && sizeof(_Functor) <= _M_max_size
         && __alignof__(_Functor) <= _M_max_align
         && (_M_max_align % __alignof__(_Functor) == 0));

        typedef integral_constant<bool, __stored_locally> _Local_storage;

        // Retrieve a pointer to the function object
        static _Functor*
        _M_get_pointer(const _Any_data& __source)
        {
          const _Functor* __ptr =
            __stored_locally? std::__addressof(__source._M_access<_Functor>())
            /* have stored a pointer */ : __source._M_access<_Functor*>();
          return const_cast<_Functor*>(__ptr);
        }

        // Clone a location-invariant function object that fits within
        // an _Any_data structure.
        static void
        _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
        {
          new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
        }

        // Clone a function object that is not location-invariant or
        // that cannot fit into an _Any_data structure.
        static void
        _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
        {
          __dest._M_access<_Functor*>() =
            new _Functor(*__source._M_access<_Functor*>());
        }

        // Destroying a location-invariant object may still require
        // destruction.
        static void
        _M_destroy(_Any_data& __victim, true_type)
        {
          __victim._M_access<_Functor>().~_Functor();
        }

        // Destroying an object located on the heap.
        static void
        _M_destroy(_Any_data& __victim, false_type)
        {
          delete __victim._M_access<_Functor*>();
        }

      public:
        static bool
        _M_manager(_Any_data& __dest, const _Any_data& __source,
                   _Manager_operation __op)
        {
          switch (__op)
            {
#ifdef __GXX_RTTI
            case __get_type_info:
              __dest._M_access<const type_info*>() = &typeid(_Functor);
              break;
#endif
            case __get_functor_ptr:
              __dest._M_access<_Functor*>() = _M_get_pointer(__source);
              break;

            case __clone_functor:
              _M_clone(__dest, __source, _Local_storage());
              break;

            case __destroy_functor:
              _M_destroy(__dest, _Local_storage());
              break;
            }
          return false;
        }

        static void
        _M_init_functor(_Any_data& __functor, _Functor&& __f)
        { _M_init_functor(__functor, std::move(__f), _Local_storage()); }

        template<typename _Signature>
          static bool
          _M_not_empty_function(const function<_Signature>& __f)
          { return static_cast<bool>(__f); }

        template<typename _Tp>
          static bool
          _M_not_empty_function(const _Tp*& __fp)
          { return __fp; }

        template<typename _Class, typename _Tp>
          static bool
          _M_not_empty_function(_Tp _Class::* const& __mp)
          { return __mp; }

        template<typename _Tp>
          static bool
          _M_not_empty_function(const _Tp&)
          { return true; }

      private:
        static void
        _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
        { new (__functor._M_access()) _Functor(std::move(__f)); }

        static void
        _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
        { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
      };

    template<typename _Functor>
      class _Ref_manager : public _Base_manager<_Functor*>
      {
        typedef _Function_base::_Base_manager<_Functor*> _Base;

      public:
        static bool
        _M_manager(_Any_data& __dest, const _Any_data& __source,
                   _Manager_operation __op)
        {
          switch (__op)
            {
#ifdef __GXX_RTTI
            case __get_type_info:
              __dest._M_access<const type_info*>() = &typeid(_Functor);
              break;
#endif
            case __get_functor_ptr:
              __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
              return is_const<_Functor>::value;
              break;

            default:
              _Base::_M_manager(__dest, __source, __op);
            }
          return false;
        }

        static void
        _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
        {
          _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
        }
      };

    _Function_base() : _M_manager(0) { }

    ~_Function_base()
    {
      if (_M_manager)
        _M_manager(_M_functor, _M_functor, __destroy_functor);
    }


    bool _M_empty() const { return !_M_manager; }

    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
                                  _Manager_operation);

    _Any_data     _M_functor;
    _Manager_type _M_manager;
  };

  template<typename _Signature, typename _Functor>
    class _Function_handler;

  template<typename _Res, typename _Functor, typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), _Functor>
    : public _Function_base::_Base_manager<_Functor>
    {
      typedef _Function_base::_Base_manager<_Functor> _Base;

    public:
      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        return (*_Base::_M_get_pointer(__functor))(
            std::forward<_ArgTypes>(__args)...);
      }
    };

  template<typename _Functor, typename... _ArgTypes>
    class _Function_handler<void(_ArgTypes...), _Functor>
    : public _Function_base::_Base_manager<_Functor>
    {
      typedef _Function_base::_Base_manager<_Functor> _Base;

     public:
      static void
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        (*_Base::_M_get_pointer(__functor))(
            std::forward<_ArgTypes>(__args)...);
      }
    };

  template<typename _Res, typename _Functor, typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
    : public _Function_base::_Ref_manager<_Functor>
    {
      typedef _Function_base::_Ref_manager<_Functor> _Base;

     public:
      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        return __callable_functor(**_Base::_M_get_pointer(__functor))(
              std::forward<_ArgTypes>(__args)...);
      }
    };

  template<typename _Functor, typename... _ArgTypes>
    class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
    : public _Function_base::_Ref_manager<_Functor>
    {
      typedef _Function_base::_Ref_manager<_Functor> _Base;

     public:
      static void
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        __callable_functor(**_Base::_M_get_pointer(__functor))(
            std::forward<_ArgTypes>(__args)...);
      }
    };

  template<typename _Class, typename _Member, typename _Res,
           typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
    {
      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
        _Base;

     public:
      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
            std::forward<_ArgTypes>(__args)...);
      }
    };

  template<typename _Class, typename _Member, typename... _ArgTypes>
    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
    : public _Function_base::_Base_manager<
                 _Simple_type_wrapper< _Member _Class::* > >
    {
      typedef _Member _Class::* _Functor;
      typedef _Simple_type_wrapper<_Functor> _Wrapper;
      typedef _Function_base::_Base_manager<_Wrapper> _Base;

    public:
      static bool
      _M_manager(_Any_data& __dest, const _Any_data& __source,
                 _Manager_operation __op)
      {
        switch (__op)
          {
#ifdef __GXX_RTTI
          case __get_type_info:
            __dest._M_access<const type_info*>() = &typeid(_Functor);
            break;
#endif
          case __get_functor_ptr:
            __dest._M_access<_Functor*>() =
              &_Base::_M_get_pointer(__source)->__value;
            break;

          default:
            _Base::_M_manager(__dest, __source, __op);
          }
        return false;
      }

      static void
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
      {
        std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
            std::forward<_ArgTypes>(__args)...);
      }
    };

  /**
   *  @brief Primary class template for std::function.
   *  @ingroup functors
   *
   *  Polymorphic function wrapper.
   */
  template<typename _Res, typename... _ArgTypes>
    class function<_Res(_ArgTypes...)>
    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
      private _Function_base
    {
      typedef _Res _Signature_type(_ArgTypes...);

      template<typename _Functor>
        using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
                                 (std::declval<_ArgTypes>()...) );

      template<typename _CallRes, typename _Res1>
        struct _CheckResult
        : is_convertible<_CallRes, _Res1> { };

      template<typename _CallRes>
        struct _CheckResult<_CallRes, void>
        : true_type { };

      template<typename _Functor>
        using _Callable = _CheckResult<_Invoke<_Functor>, _Res>;

      template<typename _Cond, typename _Tp>
        using _Requires = typename enable_if<_Cond::value, _Tp>::type;

    public:
      typedef _Res result_type;

      // [3.7.2.1] construct/copy/destroy

      /**
       *  @brief Default construct creates an empty function call wrapper.
       *  @post @c !(bool)*this
       */
      function() noexcept
      : _Function_base() { }

      /**
       *  @brief Creates an empty function call wrapper.
       *  @post @c !(bool)*this
       */
      function(nullptr_t) noexcept
      : _Function_base() { }

      /**
       *  @brief %Function copy constructor.
       *  @param __x A %function object with identical call signature.
       *  @post @c bool(*this) == bool(__x)
       *
       *  The newly-created %function contains a copy of the target of @a
       *  __x (if it has one).
       */
      function(const function& __x);

      /**
       *  @brief %Function move constructor.
       *  @param __x A %function object rvalue with identical call signature.
       *
       *  The newly-created %function contains the target of @a __x
       *  (if it has one).
       */
      function(function&& __x) : _Function_base()
      {
        __x.swap(*this);
      }

      // TODO: needs allocator_arg_t

      /**
       *  @brief Builds a %function that targets a copy of the incoming
       *  function object.
       *  @param __f A %function object that is callable with parameters of
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
       *  to @c Res.
       *
       *  The newly-created %function object will target a copy of 
       *  @a __f. If @a __f is @c reference_wrapper<F>, then this function
       *  object will contain a reference to the function object @c
       *  __f.get(). If @a __f is a NULL function pointer or NULL
       *  pointer-to-member, the newly-created object will be empty.
       *
       *  If @a __f is a non-NULL function pointer or an object of type @c
       *  reference_wrapper<F>, this function will not throw.
       */
      template<typename _Functor,
               typename = _Requires<_Callable<_Functor>, void>>
        function(_Functor);

      /**
       *  @brief %Function assignment operator.
       *  @param __x A %function with identical call signature.
       *  @post @c (bool)*this == (bool)x
       *  @returns @c *this
       *
       *  The target of @a __x is copied to @c *this. If @a __x has no
       *  target, then @c *this will be empty.
       *
       *  If @a __x targets a function pointer or a reference to a function
       *  object, then this operation will not throw an %exception.
       */
      function&
      operator=(const function& __x)
      {
        function(__x).swap(*this);
        return *this;
      }

      /**
       *  @brief %Function move-assignment operator.
       *  @param __x A %function rvalue with identical call signature.
       *  @returns @c *this
       *
       *  The target of @a __x is moved to @c *this. If @a __x has no
       *  target, then @c *this will be empty.
       *
       *  If @a __x targets a function pointer or a reference to a function
       *  object, then this operation will not throw an %exception.
       */
      function&
      operator=(function&& __x)
      {
        function(std::move(__x)).swap(*this);
        return *this;
      }

      /**
       *  @brief %Function assignment to zero.
       *  @post @c !(bool)*this
       *  @returns @c *this
       *
       *  The target of @c *this is deallocated, leaving it empty.
       */
      function&
      operator=(nullptr_t)
      {
        if (_M_manager)
          {
            _M_manager(_M_functor, _M_functor, __destroy_functor);
            _M_manager = 0;
            _M_invoker = 0;
          }
        return *this;
      }

      /**
       *  @brief %Function assignment to a new target.
       *  @param __f A %function object that is callable with parameters of
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
       *  to @c Res.
       *  @return @c *this
       *
       *  This  %function object wrapper will target a copy of @a
       *  __f. If @a __f is @c reference_wrapper<F>, then this function
       *  object will contain a reference to the function object @c
       *  __f.get(). If @a __f is a NULL function pointer or NULL
       *  pointer-to-member, @c this object will be empty.
       *
       *  If @a __f is a non-NULL function pointer or an object of type @c
       *  reference_wrapper<F>, this function will not throw.
       */
      template<typename _Functor>
        _Requires<_Callable<_Functor>, function&>
        operator=(_Functor&& __f)
        {
          function(std::forward<_Functor>(__f)).swap(*this);
          return *this;
        }

      /// @overload
      template<typename _Functor>
        function&
        operator=(reference_wrapper<_Functor> __f) noexcept
        {
          function(__f).swap(*this);
          return *this;
        }

      // [3.7.2.2] function modifiers

      /**
       *  @brief Swap the targets of two %function objects.
       *  @param __x A %function with identical call signature.
       *
       *  Swap the targets of @c this function object and @a __f. This
       *  function will not throw an %exception.
       */
      void swap(function& __x)
      {
        std::swap(_M_functor, __x._M_functor);
        std::swap(_M_manager, __x._M_manager);
        std::swap(_M_invoker, __x._M_invoker);
      }

      // TODO: needs allocator_arg_t
      /*
      template<typename _Functor, typename _Alloc>
        void
        assign(_Functor&& __f, const _Alloc& __a)
        {
          function(allocator_arg, __a,
                   std::forward<_Functor>(__f)).swap(*this);
        }
      */

      // [3.7.2.3] function capacity

      /**
       *  @brief Determine if the %function wrapper has a target.
       *
       *  @return @c true when this %function object contains a target,
       *  or @c false when it is empty.
       *
       *  This function will not throw an %exception.
       */
      explicit operator bool() const noexcept
      { return !_M_empty(); }

      // [3.7.2.4] function invocation

      /**
       *  @brief Invokes the function targeted by @c *this.
       *  @returns the result of the target.
       *  @throws bad_function_call when @c !(bool)*this
       *
       *  The function call operator invokes the target function object
       *  stored by @c this.
       */
      _Res operator()(_ArgTypes... __args) const;

#ifdef __GXX_RTTI
      // [3.7.2.5] function target access
      /**
       *  @brief Determine the type of the target of this function object
       *  wrapper.
       *
       *  @returns the type identifier of the target function object, or
       *  @c typeid(void) if @c !(bool)*this.
       *
       *  This function will not throw an %exception.
       */
      const type_info& target_type() const noexcept;

      /**
       *  @brief Access the stored target function object.
       *
       *  @return Returns a pointer to the stored target function object,
       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
       *  pointer.
       *
       * This function will not throw an %exception.
       */
      template<typename _Functor>       _Functor* target() noexcept;

      /// @overload
      template<typename _Functor> const _Functor* target() const noexcept;
#endif

    private:
      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
      _Invoker_type _M_invoker;
  };

  // Out-of-line member definitions.
  template<typename _Res, typename... _ArgTypes>
    function<_Res(_ArgTypes...)>::
    function(const function& __x)
    : _Function_base()
    {
      if (static_cast<bool>(__x))
        {
          _M_invoker = __x._M_invoker;
          _M_manager = __x._M_manager;
          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
        }
    }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor, typename>
      function<_Res(_ArgTypes...)>::
      function(_Functor __f)
      : _Function_base()
      {
        typedef _Function_handler<_Signature_type, _Functor> _My_handler;

        if (_My_handler::_M_not_empty_function(__f))
          {
            _My_handler::_M_init_functor(_M_functor, std::move(__f));
            _M_invoker = &_My_handler::_M_invoke;
            _M_manager = &_My_handler::_M_manager;
          }
      }

  template<typename _Res, typename... _ArgTypes>
    _Res
    function<_Res(_ArgTypes...)>::
    operator()(_ArgTypes... __args) const
    {
      if (_M_empty())
        __throw_bad_function_call();
      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
    }

#ifdef __GXX_RTTI
  template<typename _Res, typename... _ArgTypes>
    const type_info&
    function<_Res(_ArgTypes...)>::
    target_type() const noexcept
    {
      if (_M_manager)
        {
          _Any_data __typeinfo_result;
          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
          return *__typeinfo_result._M_access<const type_info*>();
        }
      else
        return typeid(void);
    }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor>
      _Functor*
      function<_Res(_ArgTypes...)>::
      target() noexcept
      {
        if (typeid(_Functor) == target_type() && _M_manager)
          {
            _Any_data __ptr;
            if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
                && !is_const<_Functor>::value)
              return 0;
            else
              return __ptr._M_access<_Functor*>();
          }
        else
          return 0;
      }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor>
      const _Functor*
      function<_Res(_ArgTypes...)>::
      target() const noexcept
      {
        if (typeid(_Functor) == target_type() && _M_manager)
          {
            _Any_data __ptr;
            _M_manager(__ptr, _M_functor, __get_functor_ptr);
            return __ptr._M_access<const _Functor*>();
          }
        else
          return 0;
      }
#endif

  // [20.7.15.2.6] null pointer comparisons

  /**
   *  @brief Compares a polymorphic function object wrapper against 0
   *  (the NULL pointer).
   *  @returns @c true if the wrapper has no target, @c false otherwise
   *
   *  This function will not throw an %exception.
   */
  template<typename _Res, typename... _Args>
    inline bool
    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
    { return !static_cast<bool>(__f); }

  /// @overload
  template<typename _Res, typename... _Args>
    inline bool
    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
    { return !static_cast<bool>(__f); }

  /**
   *  @brief Compares a polymorphic function object wrapper against 0
   *  (the NULL pointer).
   *  @returns @c false if the wrapper has no target, @c true otherwise
   *
   *  This function will not throw an %exception.
   */
  template<typename _Res, typename... _Args>
    inline bool
    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
    { return static_cast<bool>(__f); }

  /// @overload
  template<typename _Res, typename... _Args>
    inline bool
    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
    { return static_cast<bool>(__f); }

  // [20.7.15.2.7] specialized algorithms

  /**
   *  @brief Swap the targets of two polymorphic function object wrappers.
   *
   *  This function will not throw an %exception.
   */
  template<typename _Res, typename... _Args>
    inline void
    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
    { __x.swap(__y); }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++11

#endif // _GLIBCXX_FUNCTIONAL

這個實現的原理與上面分析的大致相同，使用函數指針實現多態，也使用了small object optimization。

注：標准庫的文件的縮進是2格，有時8個空格會用一個tab代替，在將tab顯示為4字節的編輯器中縮進會比較亂，我已經把tab全部替換為8個空格；很多人縮進習慣是4格，但如果把2格全部替換成4格也會亂了格式，所以以下摘錄自標准庫文件的代碼全部都是2格縮進。

 

2.1 類型系統

類型之間的關系，無非是繼承、嵌套、組合。這個實現中三者都有。

關於繼承，你也許會問，我們剛才不是說了這種實現沒法用繼承嗎？實際上沒有矛盾。剛才說的繼承，是接口上的繼承，講得更具體點就是要繼承虛函數，是一種is-a的關系；而這里的繼承，是實現上的繼承，是一種is-implemented-in-terms-of的關系，在語言層面大多是private繼承。

在泛型編程中，還有一個關於繼承的問題，就是在繼承體系的哪一層引入模板參數。

嵌套，即類中定義嵌套類型，使類之間的結構更加清晰，在泛型編程中還可以簡化設計。

組合，在於一個類的對象中包含其他類的對象，本應屬於對象關系的范疇，但是在這個實現中，一個類一般不會在同一個scope內出現多個對象，因此我這里就直接把對象組合的概念拿來用了。

2.1.1 異常類

首先出現的是 bad_function_call 類型，這是一個異常類，當調用空 std::function 對象時拋出：

class bad_function_call : public std::exception
{
public:
  virtual ~bad_function_call() noexcept;
  const char* what() const noexcept;
};

由於不是模板類（難得能在STL中發現非模板類），實現被編譯好放在了目標文件中。雖然GCC開源，但既然這個類不太重要，而且稍微想想就能知道它是怎么實現的了，所以這里就不深究了。

相關的還有一個用於拋出異常的函數：

void __throw_bad_function_call() __attribute__((__noreturn__));

在 <bits/functexcept.h> 中。同樣只有聲明沒有定義。

2.1.2 數據存儲

有關數據存儲的類共有3個：

class _Undefined_class;

union _Nocopy_types
{
  void*       _M_object;
  const void* _M_const_object;
  void (*_M_function_pointer)();
  void (_Undefined_class::*_M_member_pointer)();
};

union _Any_data
{
  void*       _M_access()       { return &_M_pod_data[0]; }
  const void* _M_access() const { return &_M_pod_data[0]; }

  template<typename _Tp>
    _Tp&
    _M_access()
    { return *static_cast<_Tp*>(_M_access()); }

  template<typename _Tp>
    const _Tp&
    _M_access() const
    { return *static_cast<const _Tp*>(_M_access()); }

  _Nocopy_types _M_unused;
  char _M_pod_data[sizeof(_Nocopy_types)];
};

_Undefined_class ，顧名思義，連定義都沒有，只是用於聲明 _Nocopy_types 中的成員指針數據域，因為同一個平台上成員指針的大小是相同的。

_Nocopy_types ，是4種類型的聯合體類型，分別為指針、常量指針、函數指針與成員指針。“nocopy”指的是這幾種類型指向的對象類型，而不是本身。

_Any_data ，是兩種類型的聯合體類型，一個是 _Nocopy_types ，另一個是 char 數組，兩者大小相等。后者是POD的，POD的好處多啊，memcpy可以用，最重要的是復制不會拋異常。非模板 _M_access() 返回指針，模板 _M_access() 返回解引用的結果，兩者都有 const 重載。

2.1.3 輔助類

enum _Manager_operation
{
  __get_type_info,
  __get_functor_ptr,
  __clone_functor,
  __destroy_functor
};

_Manager_operation ，枚舉類，是前面所說控制 std::function 的函數指針需要的參數類型。定義了4種操作：獲得 type_info 、獲得仿函數（就是函數對象）指針、復制仿函數、銷毀（析構）仿函數。從這個定義中可以看出，1.4節所說的各種功能中，需要延遲調用的，除了函數對象調用以外，都可以通過這4個功能來組合起來。我們后面還會進一步探討這個問題。

template<typename _Tp>
  struct __is_location_invariant
  : integral_constant<bool, (is_pointer<_Tp>::value
                             || is_member_pointer<_Tp>::value)>
  { };

__is_location_invariant ，一個trait類，判斷一個類型是不是“位置不變”的。從字面上來理解，一個類型如果是“位置不變”的，那么對於一個這種類型的對象，無論它復制到哪里，各個對象的底層表示都是相同的。在這個定義中，一個類型是“位置不變”的，當且僅當它是一個指針或成員指針，與一般的理解有所不同（更新：后來改為 template<typename _Tp> struct __is_location_invariant : is_trivially_copyable<_Tp>::type { }; ，這就比較容易理解了）。

template<typename _Tp>
  struct _Simple_type_wrapper
  {
    _Simple_type_wrapper(_Tp __value) : __value(__value) { }

    _Tp __value;
  };

template<typename _Tp>
  struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
  : __is_location_invariant<_Tp>
  { };

_Simple_type_wrapper ，一個簡單的包裝器，用於避免 void* 與指針的指針之間類型轉換的 const 問題。以及 __is_location_invariant 對 _Simple_type_wrapper 的偏特化。

2.1.4 內存管理基類

類 _Function_base 定義了一系列用於管理函數對象內存的函數，這是一個非模板類：

class _Function_base  2 {  3 public:  4   static const std::size_t _M_max_size = sizeof(_Nocopy_types);  5   static const std::size_t _M_max_align = __alignof__(_Nocopy_types);  6 
  template<typename _Functor>
    class _Base_manager;  9 
  template<typename _Functor>
    class _Ref_manager; 12 
  _Function_base() : _M_manager(0) { } 14 
  ~_Function_base() 16  { 17     if (_M_manager) 18  _M_manager(_M_functor, _M_functor, __destroy_functor); 19  } 20 
  bool _M_empty() const { return !_M_manager; } 22 
  typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, 24  _Manager_operation); 25 
 _Any_data _M_functor; 27  _Manager_type _M_manager; 28 };

_Function_base 是 std::function 的實現基類，定義了兩個靜態常量，用於后面的trait類；兩個內部類，用於包裝靜態方法；函數指針類型 _Manager_type 的對象 _M_manager ，用於存取 _Any_data 類型的 _M_functor 中的數據；構造函數，將函數指針置為空；析構函數，調用函數指針，銷毀函數對象；_M_empty() 方法，檢測內部是否存有函數對象。

我們來看其中的 _Base_manager 類：

template<typename _Functor>
  class _Base_manager
  {
  protected:
    static const bool __stored_locally =
    (__is_location_invariant<_Functor>::value
     && sizeof(_Functor) <= _M_max_size
     && __alignof__(_Functor) <= _M_max_align
     && (_M_max_align % __alignof__(_Functor) == 0));

    typedef integral_constant<bool, __stored_locally> _Local_storage;

    static _Functor*
    _M_get_pointer(const _Any_data& __source);

    static void
    _M_clone(_Any_data& __dest, const _Any_data& __source, true_type);

    static void
    _M_clone(_Any_data& __dest, const _Any_data& __source, false_type);

    static void
    _M_destroy(_Any_data& __victim, true_type);

    static void
    _M_destroy(_Any_data& __victim, false_type);

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
               _Manager_operation __op);

    static void
    _M_init_functor(_Any_data& __functor, _Functor&& __f);

    template<typename _Signature>
      static bool
      _M_not_empty_function(const function<_Signature>& __f);

    template<typename _Tp>
      static bool
      _M_not_empty_function(const _Tp*& __fp);

    template<typename _Class, typename _Tp>
      static bool
      _M_not_empty_function(_Tp _Class::* const& __mp);

    template<typename _Tp>
      static bool
      _M_not_empty_function(const _Tp&);

  private:
    static void
    _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type);

    static void
    _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type);
  };

定義了一個靜態布爾常量 __stored_locally ，它為真當且僅當 __is_location_invariant trait為真、仿函數放得下、仿函數的align符合兩個要求。然后再反過來根據這個值定義trait類 _Local_storage （標准庫里一般都是根據value trait來生成value）。

其余幾個靜態方法，顧名思義即可。有個值得思考的問題，就是為什么 _M_init_functor 是public的，沒有被放進 _M_manager 呢？

再來看 _Ref_manager 類：

template<typename _Functor>
  class _Ref_manager : public _Base_manager<_Functor*>
  {
    typedef _Function_base::_Base_manager<_Functor*> _Base;

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
               _Manager_operation __op);

    static void
    _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f);
  };

_Ref_manager 繼承自 _Base_manager 類，覆寫了兩個靜態方法。

2.1.5 仿函數調用

起輔助作用的模板函數 __callable_functor ：

template<typename _Functor>
  inline _Functor&
  __callable_functor(_Functor& __f)
  { return __f; }

template<typename _Member, typename _Class>
  inline _Mem_fn<_Member _Class::*>
  __callable_functor(_Member _Class::* &__p)
  { return std::mem_fn(__p); }

template<typename _Member, typename _Class>
  inline _Mem_fn<_Member _Class::*>
  __callable_functor(_Member _Class::* const &__p)
  { return std::mem_fn(__p); }

template<typename _Member, typename _Class>
  inline _Mem_fn<_Member _Class::*>
  __callable_functor(_Member _Class::* volatile &__p)
  { return std::mem_fn(__p); }

template<typename _Member, typename _Class>
  inline _Mem_fn<_Member _Class::*>
  __callable_functor(_Member _Class::* const volatile &__p)
  { return std::mem_fn(__p); }

對非成員指針類型，直接返回參數本身；對成員指針類型，返回 mem_fn() 的結果（將類對象轉換為第一個參數；這個標准庫函數的實現不在這篇文章中涉及），並有cv-qualified重載。它改變了調用的形式，把所有的參數都放在了小括號中。

_Function_handler 類，管理仿函數調用：

template<typename _Signature, typename _Functor>
  class _Function_handler;

template<typename _Res, typename _Functor, typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Functor>
  : public _Function_base::_Base_manager<_Functor>
  {
    typedef _Function_base::_Base_manager<_Functor> _Base;

  public:
    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

template<typename _Functor, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), _Functor>
  : public _Function_base::_Base_manager<_Functor>
  {
    typedef _Function_base::_Base_manager<_Functor> _Base;

   public:
    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

template<typename _Res, typename _Functor, typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
  : public _Function_base::_Ref_manager<_Functor>
  {
    typedef _Function_base::_Ref_manager<_Functor> _Base;

   public:
    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

template<typename _Functor, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
  : public _Function_base::_Ref_manager<_Functor>
  {
    typedef _Function_base::_Ref_manager<_Functor> _Base;

   public:
    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

template<typename _Class, typename _Member, typename _Res,
         typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
  : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
  {
    typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
      _Base;

   public:
    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

template<typename _Class, typename _Member, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), _Member _Class::*>
  : public _Function_base::_Base_manager<
               _Simple_type_wrapper< _Member _Class::* > >
  {
    typedef _Member _Class::* _Functor;
    typedef _Simple_type_wrapper<_Functor> _Wrapper;
    typedef _Function_base::_Base_manager<_Wrapper> _Base;

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
               _Manager_operation __op);

    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes... __args);
  };

共有6個特化版本：返回值類型為 void 、其他；函數對象類型為 std::reference_wrapper 、成員指針、其他。

繼承自 _Function_base::_Base_manager 或 _Function_base::_Ref_manager ，提供了靜態方法 _M_invoke() ，用於仿函數調用。有一個覆寫的 _M_manager() ，表面上看是一個偏特化有覆寫，實際上是兩個，因為返回非 void 的成員指針偏特化版本還繼承了其對應 void 偏特化版本。

2.1.6 接口定義

終於回到偉大的 std::function 了，但是我們還得再看點別的：

template<typename _Arg, typename _Result>
  struct unary_function
  {
    typedef _Arg     argument_type;   

    typedef _Result     result_type;  
  };

template<typename _Arg1, typename _Arg2, typename _Result>
  struct binary_function
  {
    typedef _Arg1     first_argument_type; 

    typedef _Arg2     second_argument_type;

    typedef _Result     result_type;
  };

std::unary_function 與 std::binary_function ，定義了一元和二元函數的參數類型與返回值類型。

template<typename _Res, typename... _ArgTypes>
  struct _Maybe_unary_or_binary_function { };

template<typename _Res, typename _T1>
  struct _Maybe_unary_or_binary_function<_Res, _T1>
  : std::unary_function<_T1, _Res> { };

template<typename _Res, typename _T1, typename _T2>
  struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
  : std::binary_function<_T1, _T2, _Res> { };

_Maybe_unary_or_binary_function 類，當模板參數表示的函數為一元或二元時，分別繼承 std::unary_function 與 std::binary_function 。

現在可以給出 std::function 類定義與方法聲明：

template<typename _Signature>
  class function;

template<typename _Res, typename... _ArgTypes>
  class function<_Res(_ArgTypes...)>
  : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
    private _Function_base
  {
    typedef _Res _Signature_type(_ArgTypes...);

    template<typename _Functor>
      using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
                               (std::declval<_ArgTypes>()...) );

    template<typename _CallRes, typename _Res1>
      struct _CheckResult
      : is_convertible<_CallRes, _Res1> { };

    template<typename _CallRes>
      struct _CheckResult<_CallRes, void>
      : true_type { };

    template<typename _Functor>
      using _Callable = _CheckResult<_Invoke<_Functor>, _Res>;

    template<typename _Cond, typename _Tp>
      using _Requires = typename enable_if<_Cond::value, _Tp>::type;

  public:
    typedef _Res result_type;

    function() noexcept;

    function(nullptr_t) noexcept;

    function(const function& __x);

    function(function&& __x);

    // TODO: needs allocator_arg_t

    template<typename _Functor,
             typename = _Requires<_Callable<_Functor>, void>>
      function(_Functor);

    function&
    operator=(const function& __x);

    function&
    operator=(function&& __x);

    function&
    operator=(nullptr_t);

    template<typename _Functor>
      _Requires<_Callable<_Functor>, function&>
      operator=(_Functor&& __f);

    template<typename _Functor>
      function&
      operator=(reference_wrapper<_Functor> __f) noexcept;
    void swap(function& __x);

    // TODO: needs allocator_arg_t
    /*
    template<typename _Functor, typename _Alloc>
      void
      assign(_Functor&& __f, const _Alloc& __a);
    */

    explicit operator bool() const noexcept;

    _Res operator()(_ArgTypes... __args) const;

#ifdef __GXX_RTTI
    const type_info& target_type() const noexcept;

    template<typename _Functor>       _Functor* target() noexcept;

    template<typename _Functor> const _Functor* target() const noexcept;
#endif

  private:
    typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
    _Invoker_type _M_invoker;
};

template<typename _Res, typename... _Args>
  inline bool
  operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept;

template<typename _Res, typename... _Args>
  inline bool
  operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept;

template<typename _Res, typename... _Args>
  inline bool
  operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept;

template<typename _Res, typename... _Args>
  inline bool
  operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept;

template<typename _Res, typename... _Args>
  inline void
  swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y);

前面說過，std::function 類的模板參數是一個函數類型。一個函數類型也是一個類型；std::function 只在模板參數是函數類型時才有意義；因此，有用的 std::function 是一個特化的模板，需要一個聲明。標准庫規定沒有特化的聲明是沒有定義的。

std::function 繼承自兩個類：公有繼承模板類 _Maybe_unary_or_binary_function ，私有繼承非模板類 _Function_base 。

前者是公有繼承，但實際上沒有繼承虛函數，不屬於接口繼承，而是實現繼承，繼承的是基類定義的類型別名。因為這些類型別名是面向客戶的，所以必須公有繼承。這個繼承使 std::function 在不同數量的模板參數的實例化下定義不同的類型別名。繼承是實現這種功能的唯一方法，SFINAE不行。（這是本文第一次出現SFINAE這個詞，我默認你看得懂。這是泛型編程中的常用技巧，如果不會請參考這篇文章或Google。）

后者是私有繼承，也屬於實現繼承，繼承了基類的兩個數據域與幾個靜態方法。

_Signature_type 是一個類型別名，就是模板參數，是一個函數類型。

_Invoke 是一個別名模板，就是仿函數被按參數類型調用的返回類型。如果不能調用，根據SFINAE，S錯誤不會E，但這個別名只有一個定義，在使用的地方所有S都E了，編譯器還是會給E。

_CheckResult 是一個trait類，檢測第一個模板參數能否轉換為第二個。另有第二個參數為 void 的偏特化，在類型檢測上使返回類型為 void 的 std::function 對象能支持任何返回值的函數對象。

_Callable 也是一個trait類，利用上面兩個定義檢測仿函數類型與 std::function 模板參數是否匹配。

_Requires 是一個有趣的別名模板，如果模板參數中第一個value trait為 true ，則定義為第二個模板參數，否則未定義（是沒有，不是 void ），使用時將交給SFINAE處理。它大致上實現了C++20中 require 關鍵字的功能。實際上concept在2005年就有proposal了，一路從C++0x拖到C++20。我計划在C++20標准正式發布之前寫一篇文章完整介紹concept。

result_type 是模板參數函數類型的返回值類型，與基類中定義的相同。

在類定義最后的私有段，還定義了一個函數指針類型以及該類型的一個對象，這是第二個函數指針。

其余的各種函數，在1.4節都介紹過了。

2.1.7 類型關系

講了這么多類型，你記住它們之間的關系了嗎？我們再來自頂向下地梳理一遍。

一個 std::function 對象中包含一個函數指針，它會被初始化為 _Function_handler 類中的靜態函數的指針。std::function 與 _Function_handler 類之間，可以認為是組合關系。

std::function 繼承自 _Maybe_unary_or_binary_function 與 _Function_base ，兩者都是實現繼承。

_Function_base 中有 _Base_manager 與 _Ref_manager 兩個嵌套類型，其中后者還繼承了前者，並覆寫了幾個方法。兩個類定義了一系列靜態方法，繼承只是為了避免代碼重復。

_Function_base 含有兩個數據域，一個是函數指針，_Function_base 與兩個嵌套類型之間既是嵌套又是組合；另一個是 _Any_data 類型對象，_Function_base 與 _Any_data 之間是組合關系。

而 _Any_data 是一個聯合體，是兩部分相同大小數據的聯合，分別是 char 數組和 _Nocopy_types 類型對象，后者又是4種基本類型的聯合。

其余的一些類與函數，都是起輔助作用的。至此，對 std::function 定義的分析就結束了。

 

2.2 方法的功能與實現

2.2.1 多態性的體現

之前一直講，std::function 是一個多態的函數對象包裝器，其中的難點就在於多態。什么是多態？你能看到這里，水平肯定不低，不知道多態是不可能的。Wikipedia對polymorphism的定義是：In programming languages and type theory, polymorphism is the provision of a single interface to entities of different types or the use of a single symbol to represent multiple different types.

可以說，我們要在 std::function 中處理好多態，就是要處理好類型。類型當然不能一個個枚舉，但可以分類。這里可以分類的有兩處：接口類型，即組成模板參數的類型，以及實現類型，即綁定的仿函數的類型。下面，我們就從這兩個角度入手，分析 std::function 是如何實現的。

2.2.2 本地函數對象

先根據仿函數類型分類，可以在 std::function 對象內部存儲的，無需heap空間的，在這一節討論。相關的方法有以下3個：

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
  { new (__functor._M_access()) _Functor(std::move(__f)); }

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
  {
    new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
  }

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_destroy(_Any_data& __victim, true_type)
  {
    __victim._M_access<_Functor>().~_Functor();
  }

_M_init_functor 用於初始化對象，在空白區域上用placement new 移動構造了函數對象。

_M_clone 用於復制對象，在目標的空白區域上用placement new 拷貝構造和函數對象。

_M_destroy 用於銷毀對象，對函數對象顯式調用了析構函數。

2.2.3 heap函數對象

然后來看函數對象存儲在heap上的情況：

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
  { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
  {
    __dest._M_access<_Functor*>() =
      new _Functor(*__source._M_access<_Functor*>());
  }

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_destroy(_Any_data& __victim, false_type)
  {
    delete __victim._M_access<_Functor*>();
  }

_M_access<_Functor*>() 將空白區域解釋為仿函數的指針，並返回其引用，實現了這片區域的分時復用。前兩個方法都比前一種情況多一層間接，而銷毀方法則直接調用了 delete 。

2.2.4 兩種存儲結構如何統一

盡管我們不得不分類討論，但為了方便使用，還需要一個統一的接口。不知你有沒有注意到，上面每一個方法都有一個未命名的參數放在最后，在方法中也沒有用到。前一種情況，這個參數都是 true_type 類型，而后一種都是 false_type 類型。這個技巧稱為tag dispatching，在調用時根據類型特征確定這個位置的參數類型，從而通過重載決定調用哪一個。

template<typename _Functor>
  static void
  _Function_base::_Base_manager<_Functor>::
  _M_init_functor(_Any_data& __functor, _Functor&& __f)
  { _M_init_functor(__functor, std::move(__f), _Local_storage()); }

template<typename _Functor>
  static bool
  _Function_base::_Base_manager<_Functor>::
  _M_manager(_Any_data& __dest, const _Any_data& __source,
             _Manager_operation __op)
  {
    switch (__op)
      {
  #ifdef __GXX_RTTI
      case __get_type_info:
        __dest._M_access<const type_info*>() = &typeid(_Functor);
        break;
  #endif
      case __get_functor_ptr:
        __dest._M_access<_Functor*>() = _M_get_pointer(__source);
        break;

      case __clone_functor:
        _M_clone(__dest, __source, _Local_storage());
        break;

      case __destroy_functor:
        _M_destroy(__dest, _Local_storage());
        break;
      }
    return false;
  }

這個版本的 _M_init_functor() 只有兩個參數，加上第三個參數委托給重載版本處理，這第三個參數是一個 _Local_storage 類的對象，它根據 __stored_locally 而成為 true_type 與 false_type ，從而區分開兩個重載。

_M_manager() 方法，同樣地，利用tag dispatching把另兩組方法統一起來。它通過第三個枚舉類型參數來確定需要的操作。

但是，這個方法的返回值是 bool ，怎么傳出 type_info 與函數對象指針呢？它們將返回值寫入第一個參數所指向的空間中。說起利用參數來傳遞返回值，我就想起C中的指針、C++中的引用、RVO、Java中的包裹類型、C#中的 out 關鍵字……這里的處理方法不僅解決了返回值的問題，同時也使各個操作的參數統一起來。

一個值得思考的問題是為什么不把 _M_init_functor() 也放到 _M_manager() 中去？答案是，調用 _M_init_functor() 的地方在 std::function 的模板構造或模板賦值函數中，此時是知道仿函數類型的；而其他操作被調用時，主調函數是不知道仿函數類型的，就必須用函數指針存儲起來；為了節省空間，就引入一個枚舉類 _Manager_operation ，把幾種操作合並到一個函數中。

實際上這一層可以先不統一，就是寫兩種情況的 _M_manager ，然后到上一層再統一，但是會增加代碼量。

除此以外，還有一種簡單的方法將兩者統一：

template<typename _Functor>
  static _Functor*
  _Function_base::_Base_manager<_Functor>::
  _M_get_pointer(const _Any_data& __source)
  {
    const _Functor* __ptr =
      __stored_locally? std::__addressof(__source._M_access<_Functor>())
                      : __source._M_access<_Functor*>();
    return const_cast<_Functor*>(__ptr);
  }

三目運算符的條件是一個靜態常量，編譯器會優化，不浪費程序空間，也不需要在運行時判斷，效果與前一種方法相同。至於另外兩個方法（指函數）為什么不用這種方法（指將兩種情況統一的方法），可能是為了可讀性吧。

2.2.5 根據形式區分仿函數類型

在下面一層解決了不同存儲結構的問題后，我們還要考慮幾種特殊情況。

_M_not_empty_function() 用於判斷參數是否非空，而不同類型的判定方法是不同的。這里的解決方案很簡單，模板方法重載即可。

template<typename _Functor>
  template<typename _Signature>
    static bool
    _Function_base::_Base_manager<_Functor>::
    _M_not_empty_function(const function<_Signature>& __f)
    { return static_cast<bool>(__f); }

template<typename _Functor>
  template<typename _Tp>
    static bool
    _Function_base::_Base_manager<_Functor>::
    _M_not_empty_function(const _Tp*& __fp)
    { return __fp; }

template<typename _Functor>
  template<typename _Class, typename _Tp>
    static bool
    _Function_base::_Base_manager<_Functor>::
    _M_not_empty_function(_Tp _Class::* const& __mp)
    { return __mp; }

template<typename _Functor>
  template<typename _Tp>
    static bool
    _Function_base::_Base_manager<_Functor>::
    _M_not_empty_function(const _Tp&)
    { return true; }

在調用時，普通函數對象、std::reference_wrapper 對象與成員指針的調用方法是不同的，也需要分類討論。

template<typename _Res, typename _Functor, typename... _ArgTypes>
  static _Res
  _Function_handler<_Res(_ArgTypes...), _Functor>::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    return (*_Base::_M_get_pointer(__functor))(
        std::forward<_ArgTypes>(__args)...);
  }

對於普通函數對象，函數調用沒什么特殊的。注意自定義 operator() 必須是 const 的。

對於 std::reference_wrapper 對象，由於包裝的對象存儲為指針，因此存儲結構與普通函數對象有所不同，相應地調用也不同。

template<typename _Functor>
  static void
  _Function_base::_Ref_manager<_Functor>::
  _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
  {
    _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
  }

template<typename _Functor>
  static bool
  _Function_base::_Ref_manager<_Functor>::
  _M_manager(_Any_data& __dest, const _Any_data& __source,
             _Manager_operation __op)
  {
    switch (__op)
      {
  #ifdef __GXX_RTTI
      case __get_type_info:
        __dest._M_access<const type_info*>() = &typeid(_Functor);
        break;
  #endif
      case __get_functor_ptr:
        __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
        return is_const<_Functor>::value;
        break;

      default:
        _Base::_M_manager(__dest, __source, __op);
      }
    return false;
  }

template<typename _Res, typename _Functor, typename... _ArgTypes>
  static _Res
  _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    return __callable_functor(**_Base::_M_get_pointer(__functor))(
        std::forward<_ArgTypes>(__args)...);
  }

碰到兩個星號是不是有點暈？其實只要想，一般情況下存儲函數對象的地方現在存儲指針，所以要獲得原始對象，只需要比一般情況多一次解引用，這樣就容易理解了。

對於成員指針，情況又有一點不一樣：

template<typename _Class, typename _Member, typename... _ArgTypes>
  static bool
  _Function_handler<void(_ArgTypes...), _Member _Class::*>::
  _M_manager(_Any_data& __dest, const _Any_data& __source,
             _Manager_operation __op)
  {
    switch (__op)
      {
#ifdef __GXX_RTTI
      case __get_type_info:
        __dest._M_access<const type_info*>() = &typeid(_Functor);
        break;
#endif
      case __get_functor_ptr:
        __dest._M_access<_Functor*>() =
          &_Base::_M_get_pointer(__source)->__value;
        break;

      default:
        _Base::_M_manager(__dest, __source, __op);
      }
    return false;
  }

template<typename _Class, typename _Member, typename _Res,
         typename... _ArgTypes>
  static _Res
  _Function_handler<_Res(_ArgTypes...), _Member _Class::*>::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
        std::forward<_ArgTypes>(__args)...);
  }

我一直說“成員指針”，而不是“成員函數指針”，是因為數據成員指針也是可以綁定的，這種情況在 std::mem_fn() 中已經處理好了。

void 返回類型的偏特化本應接下來討論，但之前講過，這個函數被通過繼承復用了。實際上，如果把這里的 void 改為模板類型，然后交換兩個 _Function_handler 偏特化的繼承關系，效果還是一樣的，所以就在這里先討論了。

最后一個需要區分的類型，是返回值類型，屬於接口類型。之前都是非 void 版本，下面還有幾個 void 的偏特化：

template<typename _Functor, typename... _ArgTypes>
  static void
  _Function_handler<void(_ArgTypes...), _Functor>::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    (*_Base::_M_get_pointer(__functor))(
        std::forward<_ArgTypes>(__args)...);
  }

template<typename _Functor, typename... _ArgTypes>
  static void
  _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    __callable_functor(**_Base::_M_get_pointer(__functor))(
        std::forward<_ArgTypes>(__args)...);
  }

template<typename _Class, typename _Member, typename... _ArgTypes>
  static void
  _Function_handler<void(_ArgTypes...), _Member _Class::*>::
  _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
  {
    std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
        std::forward<_ArgTypes>(__args)...);
  }

void 只是刪除了 return 關鍵字的非 void 版本，因此 void 返回類型的 std::function 對象可以綁定任何返回值的函數對象。

2.2.6 實現組裝成接口

我們終於討論完了各種情況，接下來讓我們來見證 std::function 的大和諧：如何用這些方法組裝成 std::function 。

template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function() noexcept
  : _Function_base() { }

template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function(nullptr_t) noexcept
  : _Function_base() { }

template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function(function&& __x) : _Function_base()
  {
    __x.swap(*this);
  }

template<typename _Res, typename... _ArgTypes>
  auto
  function<_Res(_ArgTypes...)>::
  operator=(const function& __x)
  -> function&
  {
    function(__x).swap(*this);
    return *this;
  }

template<typename _Res, typename... _ArgTypes>
  auto
  function<_Res(_ArgTypes...)>::
  operator=(function&& __x)
  -> function&
  {
    function(std::move(__x)).swap(*this);
    return *this;
  }

template<typename _Res, typename... _ArgTypes>
  auto
  function<_Res(_ArgTypes...)>::
  operator=(nullptr_t)
  -> function&
  {
    if (_M_manager)
      {
        _M_manager(_M_functor, _M_functor, __destroy_functor);
        _M_manager = 0;
        _M_invoker = 0;
      }
    return *this;
  }

template<typename _Functor>
  auto
  function<_Res(_ArgTypes...)>::
  operator=(_Functor&& __f)
  -> _Requires<_Callable<_Functor>, function&>
  {
    function(std::forward<_Functor>(__f)).swap(*this);
    return *this;
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    auto
    function<_Res(_ArgTypes...)>::
    -> function&
    operator=(reference_wrapper<_Functor> __f) noexcept
    {
      function(__f).swap(*this);
      return *this;
    }

template<typename _Res, typename... _ArgTypes>
  void
  function<_Res(_ArgTypes...)>::
  swap(function& __x)
  {
    std::swap(_M_functor, __x._M_functor);
    std::swap(_M_manager, __x._M_manager);
    std::swap(_M_invoker, __x._M_invoker);
  }

template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  operator bool() const noexcept
  { return !_M_empty(); }

template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function(const function& __x)
  : _Function_base()
  {
    if (static_cast<bool>(__x))
      {
        _M_invoker = __x._M_invoker;
        _M_manager = __x._M_manager;
        __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
      }
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor, typename>
    function<_Res(_ArgTypes...)>::
    function(_Functor __f)
    : _Function_base()
    {
      typedef _Function_handler<_Signature_type, _Functor> _My_handler;

      if (_My_handler::_M_not_empty_function(__f))
        {
          _My_handler::_M_init_functor(_M_functor, std::move(__f));
          _M_invoker = &_My_handler::_M_invoke;
          _M_manager = &_My_handler::_M_manager;
        }
    }

template<typename _Res, typename... _ArgTypes>
  _Res
  function<_Res(_ArgTypes...)>::
  operator()(_ArgTypes... __args) const
  {
    if (_M_empty())
      __throw_bad_function_call();
    return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
  }

template<typename _Res, typename... _ArgTypes>
  const type_info&
  function<_Res(_ArgTypes...)>::
  target_type() const noexcept
  {
    if (_M_manager)
      {
        _Any_data __typeinfo_result;
        _M_manager(__typeinfo_result, _M_functor, __get_type_info);
        return *__typeinfo_result._M_access<const type_info*>();
      }
    else
      return typeid(void);
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    _Functor*
    function<_Res(_ArgTypes...)>::
    target() noexcept
    {
      if (typeid(_Functor) == target_type() && _M_manager)
        {
          _Any_data __ptr;
          if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
              && !is_const<_Functor>::value)
            return 0;
          else
            return __ptr._M_access<_Functor*>();
        }
      else
        return 0;
    }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    const _Functor*
    function<_Res(_ArgTypes...)>::
    target() const noexcept
    {
      if (typeid(_Functor) == target_type() && _M_manager)
        {
          _Any_data __ptr;
          _M_manager(__ptr, _M_functor, __get_functor_ptr);
          return __ptr._M_access<const _Functor*>();
        }
      else
        return 0;
    }

template<typename _Res, typename... _Args>
  inline bool
  operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return !static_cast<bool>(__f); }

template<typename _Res, typename... _Args>
  inline bool
  operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return !static_cast<bool>(__f); }

template<typename _Res, typename... _Args>
  inline bool
  operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return static_cast<bool>(__f); }

template<typename _Res, typename... _Args>
  inline bool
  operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return static_cast<bool>(__f); }

template<typename _Res, typename... _Args>
  inline void
  swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
  { __x.swap(__y); }

我們從 swap() 開始入手。swap() 方法只是簡單地將三個數據成員交換了一下，這是正確的，因為它們存儲的都是POD類型。我認為，這個實現對函數對象存儲在本地的條件的限制太過嚴格，大小合適的可trivial復制的函數對象也應該可以存儲在本地。

在 swap() 的基礎上，拷貝構造、移動構造、拷貝賦值、移動賦值函數很自然地構建起來了，而且只用到了 swap() 方法。這種技巧稱為copy-and-swap。這也就解釋了為什么 std::function 需要那么多延遲調用的操作而表示操作的枚舉類只需要定義4種操作。

swap() 還可以成為異常安全的基礎。由於以上方法只涉及到 swap() ，而 swap() 方法是不拋異常的，因此兩個移動函數是 noexcept 的，兩個拷貝函數也能保證在棧空間足夠時不拋異常，在拋異常時不會出現內存泄漏。

其余的方法，有了前面的基礎，看代碼就能讀懂了。

 

后記

寫這篇文章花了好久呀。這是我第一次寫這么長的博客，希望你能有所收獲。如果有不懂的地方，可以在評論區留言。如果有任何錯誤，煩請指正。

我是從實現的角度來寫的這篇文章，如果你對其中的一些技巧（SFINAE、tag dispatching）不太熟悉的話，理解起來可能有點困難。相關資料[8]介紹了 function 類的設計思路，從無到有的構建過程比較容易理解。相關資料[9]分析了另一個版本的 std::function 實現，可供參考。

文章內容已經很充實了，但是沒有圖片，不太直觀。有空我會加上圖片的，這樣更容易理解。

另外，在我實現完自己的 function 類以后，還會對這篇文章作一點補充。自己造一遍輪子，總會有更深刻的感受吧。

 

附錄

相關資料：

[1] Naive std::function implementation

[2] How is std::function implemented?

[3] std::function - cppreference.com

[4] The space of design choices for std::function

[5] How true is “Want Speed? Pass by value”

[6] C++奇淫巧技之SFINAE

[7] What is the copy-and-swap idiom?

[8] std::function 基本實現

[9] std::function 源碼分析