溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“C++11中的std::function怎么用”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“C++11中的std::function怎么用”文章能幫助大家解決問題。
本文是基于gcc-4.9.0的源代碼進行分析，std::function是C++11才加入標準的，所以低版本的gcc源碼是沒有std::function的，建議選擇4.9.0或更新的版本去學習，不同版本的gcc源碼差異應該不小，但是原理和設計思想的一樣的。
類模版std::function是一種通用的多態函數包裝器。std::function的實例可以對任何可以調用的目標實體進行存儲、復制、和調用操作，這些目標實體包括普通函數指針、類成員函數指針（第一個參數需要傳入對應的this指針）、Lambda表達式或者某個類的實例（前提是這個類重載了()運算符）。std::function對象是對C++中現有的可調用實體的一種類型安全的包裹（我們知道像函數指針這類可調用實體，是類型不安全的）。
通常std::function是一個函數對象類，它包裝其它任意的可調用實體，被包裝的對象具有類型為T1,…,TN的N個參數，并且返回一個可轉換到R類型的值。std::function使用模板轉換構造函數接收被包裝的函數對象；特別是，閉包類型可以隱式地轉換為std::function。最簡單的理解就是通過std::function對C++中各種可調用實體的封裝，形成一個新的可調用的std::function對象，讓我們不再糾結那么多的可調用實體之間如何進行方便高效的轉換。
std::function位于libstdc++-v3\include\std\functional中
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 _Functor>
using _Callable = __check_func_return_type<_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_base()
{
}
function(nullptr_t) noexcept
:_Function_base()
{
}
template<typename _Res, typename... _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);
}
}
function(function&& __x)
:_Function_base()
{ __x.swap(*this); }
template<typename _Functor, typename = _Requires<_Callable<_Functor>, void>>
function(_Functor __f)
{
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;
}
}
function& operator=(const function& __x)
{
function(__x).swap(*this);
return *this;
}
function& operator=(function&& __x)
{
function(std::move(__x)).swap(*this);
return *this;
}
function& operator=(nullptr_t)
{
if (_M_manager)
{
_M_manager(_M_functor, _M_functor, __destroy_functor);
_M_manager = 0;
_M_invoker = 0;
}
return *this;
}
template<typename _Functor>
_Requires<_Callable<_Functor>, function&> operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template<typename _Functor>
function& operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
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);
}
explicit operator bool() const noexcept
{ return !_M_empty(); }
_Res operator()(_ArgTypes... __args) const;
{
if (_M_empty())
__throw_bad_function_call();
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
}
private:
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
_Invoker_type _M_invoker;從源代碼中可以看出以下幾點信息：
該類是一個可變參模板類
該類繼承于_Maybe_unary_or_binary_function（不分析）和_Function_base，類成員只有_M_invoker一個，從定義可以看出這是一個標準的函數指針
首先分析operator()方法，平時開發中std::function使用最多的肯定就是重載的括號運算符了，畢竟最終也是要把它當成類似于函數的形式來調用的。可以看到operator()函數里面調用了_M_invoker函數，并沒有什么特殊的處理
既然_M_invoker能被調用，那就說明它肯定被初始化過了，從調用時傳給他的參數來看，多了一個不知道是什么的參數_M_functor，所以我們可以猜測_M_invoker并不是直接指向std::function接管的可調用實體的，而是一個類似中間層的東西，在_M_invoker的實現里面才調用了我們需要執行的那個真實的可調用實體
只有構造函數function(_Functor __f)對_M_invoker進行了初始化，而使用的就是std::_Function_handler里的方法來初始化_M_invoker的，std::_Function_handler的實現在后面會講到
還是看構造函數function(_Functor __f)，因為std::function的目的就是對我們傳入的可調用實體進行包裝，這里說的可調用實體可以是普通函數指針、類成員函數指針（第一個參數需要傳入對應的this指針）、Lambda表達式以及某個類實例（前提是這個類重載了()運算符），而我們看到在std::function這個類里面并沒有直接托管我們傳入的可調用實體，而只是調用了_My_handler::_M_init_functor(_M_functor, std::move(__f))，推測是由_Function_base來托管可調用實體的
std::_Function_handler位于libstdc++-v3\include\std\functional中
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)...);
}
};從源代碼中可以看出_Function_handler有六種重載形式，以下對其進行分類說明：
第一個和第二個重載形式繼承于std::_Function_base::_Base_manager，當std::function接管的可調用實體是一個普通函數指針、類實例或者Lambda表達式時，發揮作用的就是這兩個類。里面的內容很簡單，通過調用_Function_base::_Base_manager<_Functor>的_M_get_pointer方法從__functor中取出對應的可調用實體，然后直接執行，我們知道能直接執行的可調用實體的類型是普通函數指針、類實例（必須重載了()運算符）或者Lambda表達式（Lambda其實本質就是一個匿名的類實例）。這兩個重載形式的唯一區別就是它們一個處理函數有返回值的情況，另一個處理沒返回值的情況。
第三個和第四個重載形式繼承于std::_Function_base::_Ref_manager，可以看出它們基本上算是前兩個類的偏特化版本，當第二個模板參數為std::reference_wrapper包裝的引用時，就調用這兩個偏特化的版本。這兩個重載形式的唯一區別也是它們一個處理函數有返回值的情況，另一個處理沒返回值的情況。現在問題來了，為什么要搞一個對于std::reference_wrapper類型的偏特化版本呢？這是因為如果可調用實體已經先被std::reference_wrapper包裝過的話，那我們是絕對絕對不能直接調用這個可調用實體的，因為此時根本不確定這個被包裝的可調用實體究竟是什么類型的，如果是類成員函數的話那當然是不能直接調用的，此時必須使用std::mem_fn來獲取一個可調用的對象，類中使用的std::__callable_functor函數的實現如下面的代碼所示，可以看到有好幾種特化版本，當std::reference_wrapper包裝的可調用實體是一個類成員函數指針時，就會通過std::mem_fn來獲取一個可調用的對象，這和前面描述的內容一致。
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); }關于上面提到的std::reference_wrapper和std::mem_fn，大家如果可以不懂的話一定要看下面兩篇文章，不然的話就像學英語不會英語單詞一樣，根本不可能看懂std::function的內容的
《C++11的std::ref、std::cref源碼解析》
《C++11的std::mem_fn源碼解析》
第五個和第六個重載形式和前面的差不多，這兩個也是屬于偏特化版本，主要是用于處理可調用實體為類成員函數指針的情況，這里就可以看到直接調用了std::men_fn函數來使得我們可以直接調用對應的類成員函數，從這點也可以看出std::men_fn函數的重要性，不懂的小伙伴一定要去看前面兩篇文章啊。
每一個類里面的_M_invoke函數都用了_M_get_pointer（來源不全部相同），從代碼邏輯上不難看出_M_get_pointer函數的作用是從第一個傳入參數__functor中取出對應的可調用實體，然后將后面的可變參傳給這個可調用實體，運行它，這個功能是不是就有點似曾相識了？對，這就是我們平時正常調用函數的那樣子嘛，也就是說std::function的函數執行功能在這里實現了
從代碼中我們可以看出這幾個類都是和std::_Function_base相關的，并且到現在還是不知道_M_functor究竟是個什么東西，接下來分析std::_Function_base，看一下里面究竟做了哪些工作
_Any_data位于libstdc++-v3\include\std\functional中
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)];
};看std::_Function_base之前先看一個重要的聯合體_Any_data，這個在前面出現很多次了，但是一直沒有介紹一下它究竟是個什么東西，下面簡單分析一下：
有兩個聯合體成員，一個是_M_unused（沒卵用），一個是_M_pod_data，這兩個的占用內存是一樣的，具體原因就不講了，大家可以自己用sizeof去試一下
里面有四個_M_access函數，前兩個是直接將_M_pod_data的地址返回出去，不做任何轉換，后兩個則是可以將_M_pod_data轉換為任意類型返回，從這里可以看出這個_Any_data的作用就是來接管可調用對象的，所以后續可以通過各種轉換將它還原為可調用的形式（比如前面提到的那個_Function_base::_Base_manager<_Functor>::_M_get_pointer方法就是干這個貨活的）
簡單看一下_Nocopy_types這個聯合體，前兩個成員的寓意就是類實例或Lambda表達式，第三個寓意是普通函數指針，第四個寓意是類成員函數指針，仔細一看這不就是我們前面提到無數次的可調用實體的幾種形式嗎？這個_Nocopy_types從上下文看來并沒有什么亂用，估計就是源碼作者寫給讀者看的吧，讓大家更容易讀懂源碼。
std::_Function_base的實現位于libstdc++-v3\include\std\functional中
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;
static _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);
}
static void _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
{
new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}
static void _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
{
__dest._M_access<_Functor*>() = new _Functor(*__source._M_access<_Functor*>());
}
static void _M_destroy(_Any_data& __victim, true_type)
{
__victim._M_access<_Functor>().~_Functor();
}
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)
{
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(_Tp* const& __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)
{
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;
};從源代碼中可以看出以下幾點信息：
該類有兩個類成員，分別是_M_functor和_M_manager，_M_functor就不用多說了，前面一直有提到它，他的類型_Any_data也在上一小節講過了。而_M_manager則是一個函數指針，下面再介紹它有什么用。
這里看一下_Function_base::_Base_manager類里面的各個方法
_M_init_functor函數：該函數前面提到過了，當時看到的是將std::function接管的可調用對象傳遞給了這個函數，而從前面我們知道_Any_data類型的數據是可以接管所有形式的可調用實體的，所以綜合可得_M_init_functor函數的作用就是將傳遞給它的第二個參數儲存到第一個參數中（_Any_data類型數據），這樣就達成了接管可調用實體的功能了
_M_get_pointer函數：這個函數同樣在前面提到過，當時我們只知道通過調用_M_get_pointer可以獲取到我們接管的那個可調用實體，但是不知道是如何實現的，這里可以看出他的實現是非常簡單的，也就是從它的傳入參數（_Any_data類型數據）將可調用實體取出，并強制轉換為合法的類型，里面用到了std::__addressof，作用就是即使目標變量（類）存在operator&的重載，也依然能夠獲得變量的地址。
關于std::__addressof的詳細內容可以看這篇文章《C++11的std::addressof源碼解析》
_M_manager函數：該函數就是根據傳入的第三個參數來確定執行不同的功能，其余的幾個函數無非就是涉及到內存的分配和釋放之類的，對我們理解std::function的影響不大，這里就不展開講了
接下來看一下_Function_base::_Ref_manager類
可以看到該類繼承于_Function_base::_Base_manager類，可見他擁有_Function_base::_Base_manager類實現的所有功能
該類是處理當std::function接管的是一個引用包裝類的情況的，為什么這種情況需要單獨處理呢？因為此時如果直接對傳入參數取地址，取到的將是引用包裝類的地址，而不是我們要接管的可調用對象的地址，所以只能搞這么一個特化版本，就像_Function_base::_Ref_manager類做的那樣，里面的_M_init_functor函數通過使用reference_wrapper的get方法獲取到了std::function接管的可調用對象的真實地址
_Function_base類里的其它方法就不講了，大家自己看一下吧，其余的實現基本都是基于前面講的那些內容，比較簡單
關于“C++11中的std::function怎么用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
