Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of "how to use std::function in Craft 11". The editor shows you the operation process through an actual case. The operation method is simple and fast, and it is practical. I hope this article "how to use std::function in Craft 11" can help you solve the problem.

1. Source code preparation

This article is based on the analysis of the source code of gcc-4.9.0, std::function is added to the standard, so the lower version of gcc source code is not std::function, it is recommended to choose 4.9.0 or newer version to learn, different versions of gcc source code should be different, but the principle and design ideas are the same.

2. Introduction to std::function

Template-like std::function is a general-purpose wrapper for polymorphic functions. Instances of std::function can store, copy, and invoke any callable target entity, including a normal function pointer, a class member function pointer (the corresponding this pointer is passed in to the first argument), an Lambda expression, or an instance of a class (provided the class overloads the () operator). The std::function object is a type-safe wrapper for existing callable entities in C++ (we know that callable entities such as function pointers are type-unsafe).

Usually std::function is a function object class that wraps any other callable entity with a type of T1, … N parameters of TN and returns a value that can be converted to type R. Std::function uses template transformation constructors to receive wrapped function objects; in particular, closure types can be implicitly converted to std::function. The simplest understanding is to encapsulate various callable entities in C++ through std::function to form a new callable std::function object, so that we no longer struggle with how to carry out convenient and efficient conversion between so many callable entities.

3. Source code analysis

3.1parsing of std::function

Std::function is located in libstdc++-v3\ include\ std\ functional

Templateclass function: public _ Maybe_unary_or_binary_function, private _ Function_base {typedef _ Res _ Signature_type (_ ArgTypes...); template using _ Invoke = decltype (_ _ callable_functor (std::declval ()) (std::declval ()...)); template using _ Callable = _ _ check_func_return_type; template using _ Requires = typename enable_if::type;public: typedef _ Res result_type Function () noexcept: _ Function_base () {} function (nullptr_t) noexcept: _ Function_base () {} template function (const function& _ x): _ Function_base () {if (static_cast (_ x)) {_ M_invoker = _ _ x._M_invoker _ M_manager = _ _ x.administrators Manager; _ _ x._M_manager (_ M_functor, _ _ x._M_functor, _ _ clone_functor);}} function (function&& _ x): _ Function_base () {_ _ x.swap (* this) } template function (_ Functor _ f) {typedef _ Function_handler _ 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 _ Requires operator= (_ Functor&& _ f) {function (std::forward (_ f)). Swap (* this); return * this;} template function& operator= (reference_wrapper _ 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 (_ _ args)...);} private: typedef _ Res (* _ Invoker_type) (const _ Any_data&, _ ArgTypes...); _ Invoker_type _ M_invoker

The following information can be seen from the source code:

This class is a variable parameter template class

This class inherits from _ Maybe_unary_or_binary_function (not parsed) and _ Function_base. There is only one member of the class, _ M_invoker. It can be seen from the definition that this is a standard function pointer.

First of all, analyze the operator () method, usually the most common use of std::function in development is the overloaded parenthesis operator, after all, it will eventually be called as a form similar to a function. You can see that the _ M_invoker function is called in the operator () function, and there is no special handling

Since _ M_invoker can be called, it must have been initialized. From the parameter passed to him during the call, there is an extra parameter _ M_functor that doesn't know what it is, so we can guess that _ M_invoker does not point directly to the callable entity taken over by std::function, but something similar to the middle tier. The real callable entity that we need to execute is called in the implementation of _ M_invoker

Only the constructor function (_ Functor _ f) initializes _ M_invoker, and the method in std::_Function_handler is used to initialize _ M_invoker. The implementation of std::_Function_handler will talk about later.

Let's look at the constructor function (_ Functor _ f), because the purpose of std::function is to wrap the callable entities we pass in, which can be ordinary function pointers, class member function pointers (the corresponding this pointer is required for the first parameter), Lambda expressions, and an instance of a class (provided the class overloads the () operator). We can see that the callable entity we passed in is not directly hosted in the std::function class, but only called _ My_handler::_M_init_functor (_ M_functor, std::move (_ _ f)). It is speculated that the callable entity is hosted by _ Function_base.

3.2.The analysis of std::_Function_handler

Std::_Function_handler is located in libstdc++-v3\ include\ std\ functional

Templateclass _ Function_handler: public _ Function_base::_Base_manager {typedef _ Function_base::_Base_manager _ Base;public: static _ Res _ M_invoke (const _ Any_data& _ functor, _ ArgTypes... _ _ args) {return (* _ Base::_M_get_pointer (_ _ functor)) (std::forward (_ _ args)...);}}; templateclass _ Function_handler: public _ Function_base::_Base_manager {typedef _ Function_base::_Base_manager _ Base;public: static void _ M_invoke (const _ Any_data& _ functor, _ ArgTypes...) _ _ args) {(* _ Base::_M_get_pointer (_ _ functor)) (std::forward (_ _ args)...);}}; templateclass _ Function_handler: public _ Function_base::_Ref_manager {typedef _ Function_base::_Ref_manager _ Base;public: static _ Res _ M_invoke (const _ Any_data& _ functor, _ ArgTypes... _ _ args) {return _ callable_functor (* * _ Base::_M_get_pointer (_ _ functor)) (std::forward (_ _ args)...);}}; templateclass _ Function_handler: public _ Function_base::_Ref_manager {typedef _ Function_base::_Ref_manager _ Base;public: static void _ M_invoke (const _ Any_data& _ functor, _ ArgTypes... _ _ args) {_ callable_functor (* * _ Base::_M_get_pointer (_ _ functor)) (std::forward (_ _ args)...);}}; templateclass _ Function_handler: public _ Function_handler {typedef _ Function_handler _ Base;public: static _ Res _ M_invoke (const _ Any_data& _ functor, _ ArgTypes... _ _ args) {return std::mem_fn (_ Base::_M_get_pointer (_ _ functor)-> _ _ value) (std::forward (_ _ args)...);}}; templateclass _ Function_handler: public _ Function_base::_Base_manager > {typedef _ Member _ Class::* _ Functor; typedef _ Simple_type_wrapper _ Wrapper; typedef _ Function_base::_Base_manager _ 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 () = & typeid (_ Functor); break # endif case _ _ get_functor_ptr: _ _ dest._M_access () = & _ 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 (_ _ args)...);}}

You can see from the source code that there are six overloaded forms of _ Function_handler, which are classified as follows:

The first and second overloaded forms inherit from std::_Function_base::_Base_manager, the two classes that play a role when the callable entity that std::function takes over is a normal function pointer, class instance, or Lambda expression. The content is very simple. By calling the _ M_get_pointer method of _ Function_base::_Base_manager to extract the corresponding callable entity from _ _ functor, and then executing it directly, we know that the type of callable entity that can be executed directly is a normal function pointer, a class instance (the () operator must be overloaded), or a Lambda expression (Lambda is essentially an anonymous class instance). The only difference between these two overloaded forms is that one handler has a return value and the other handles no return value.

The third and fourth overloaded forms inherit from std::_Function_base::_Ref_manager, so you can see that they are basically specialized versions of the first two classes, which are called when the second template parameter is a reference wrapped by std::reference_wrapper. The only difference between these two overloaded forms is that one handler has a return value and the other handles no return value. Now the question is, why make a partial version of the std::reference_wrapper type? This is because if the callable entity has been wrapped by std::reference_wrapper, we must never call the callable entity directly, because at this time we are not sure what type the wrapped callable entity is. If it is a class member function, it cannot be called directly. At this time, we must use std::mem_fn to get a callable object. The implementation of the std::__callable_functor function used in the class is shown in the following code, and you can see that there are several specialized versions. When the callable entity wrapped by std::reference_wrapper is a class member function pointer, a callable object is obtained through std::mem_fn, which is consistent with the previous description.

Templateinline _ Functor& _ callable_functor (_ Functor& _ f) {return _ f;} templateinline _ Mem_fn _ callable_functor (_ Member _ Class::* & _ p) {return std::mem_fn (_ _ p);} templateinline _ Mem_fn _ callable_functor (_ Member _ Class::* const & _ _ p) {return std::mem_fn (_ p) } templateinline _ Mem_fn _ callable_functor (_ Member _ Class::* volatile & _ p) {return std::mem_fn (_ p);} templateinline _ Mem_fn _ callable_functor (_ Member _ Class::* const volatile & _ p) {return std::mem_fn (_ p);}

With regard to the std::reference_wrapper and std::mem_fn mentioned above, if you can't understand them, you must read the following two articles, otherwise, just like learning English without knowing English words, it is impossible to understand the contents of std::function.

"std::ref and std::cref Source Code Analysis of Cellular 11"

"std::mem_fn Source Code Analysis of Cellular 11"

The fifth and sixth overloaded forms are similar to the previous ones, and these two are also partial versions, which are mainly used to deal with the case where the callable entity is a class member function pointer. Here we can see that the std::men_fn function is called directly so that we can directly call the corresponding class member function. From this point, we can also see the importance of the std::men_fn function. Friends who don't understand must read the first two articles.

The _ M_invoke function in each class uses _ M_get_pointer (not all from the same source). From the logic of the code, it is not difficult to see that the function of the _ M_get_pointer function is to extract the corresponding callable entity from the first passed parameter _ _ functor, and then pass the later variable parameters to the callable entity to run it. Isn't this function a bit familiar? Yes, this is the way we normally call functions, that is to say, the function execution function of std::function is implemented here.

We can see from the code that these classes are related to std::_Function_base, and we still don't know what _ M_functor is. Let's analyze std::_Function_base to see what work has been done in it.

3. 3. _ Any_data resolution

_ Any_data is located in libstdc++-v3\ include\ std\ functional

Union _ Nocopy_types {void* _ object; const void* _ M_function_pointer object; void (* _ M_function_pointer) (); void (_ Undefined_class::*_M_member_pointer) ();}; union _ Any_data {void* _ object () {return & _ M_pod_data [0] } const void* _ M_access () const {return & _ M_pod_data [0];} template _ Tp& _ M_access () {return * static_cast (_ M_access ();} template const _ Tp& _ M_access () const {return * static_cast (_ M_access ());} _ Nocopy_types _ masked unused; char _ masked pod _ data [sizeof (_ Nocopy_types)];}

Before looking at std::_Function_base, let's take a look at an important consortium _ Any_data. This has appeared many times before, but it hasn't been introduced. Here's a brief analysis:

There are two members of the consortium, one is _ M_unused (no egg) and the other is _ M_pod_data. The memory consumption of these two is the same. Let's not talk about the specific reasons. You can try it with sizeof yourself.

There are four _ M_access functions. The first two directly return the address of _ M_pod_data without any conversion, while the latter two can convert _ M_pod_data to any type. From this, we can see that the function of this _ Any_data is to take over the callable object. So it can be restored to a callable form later through various transformations (for example, the _ Function_base::_Base_manager::_M_get_pointer method mentioned earlier does the job).

A brief look at the _ Nocopy_types complex, the first two members of the moral is the class instance or Lambda expression, the third meaning is the ordinary function pointer, the fourth meaning is the class member function pointer, take a closer look at this is not we mentioned countless times before the callable entity of several forms? This _ Nocopy_types is not misused in the context. It is probably written by the source code author to the reader, making it easier for everyone to understand the source code.

3.4.The analysis of std::_Function_base

The implementation of std::_Function_base is located in 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 class _ Base_manager {protected: static const bool _ stored_locally = (_ _ is_location_invariant::value & & sizeof (_ Functor)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.