Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::function<R(Args...)>::function

      From cppreference.com
      <cpp‎ |utility‎ |functional‎ |function
       
       
      Utilities library
       
      Function objects
      Function invocation
      (C++17)(C++23)
      Identity function object
      (C++20)
      Old binders and adaptors
      (until C++17*)
      (until C++17*)
      (until C++17*)
      (until C++17*)  
      (until C++17*)
      (until C++17*)(until C++17*)(until C++17*)(until C++17*)
      (until C++20*)
      (until C++20*)
      (until C++17*)(until C++17*)
      (until C++17*)(until C++17*)

      (until C++17*)
      (until C++17*)(until C++17*)(until C++17*)(until C++17*)
      (until C++20*)
      (until C++20*)
       
       
      function()noexcept;
      		 (1)(since C++11)
      function(std::nullptr_t)noexcept;
      		 (2)(since C++11)
      function(const function& other);
      		 (3)(since C++11)
      (4)
      function( function&& other);
      		(since C++11)
      (until C++20)
      function( function&& other)noexcept;
      		(since C++20)
      template<class F>
      function( F&& f);
      		 (5)(since C++11)
      template<class Alloc>
      function(std::allocator_arg_t,const Alloc& alloc)noexcept;
      		 (6)(since C++11)
      (removed in C++17)
      template<class Alloc>

      function(std::allocator_arg_t,const Alloc& alloc,

               std::nullptr_t)noexcept;
      		 (7)(since C++11)
      (removed in C++17)
      template<class Alloc>

      function(std::allocator_arg_t,const Alloc& alloc,

               const function& other);
      		 (8)(since C++11)
      (removed in C++17)
      template<class Alloc>

      function(std::allocator_arg_t,const Alloc& alloc,

                function&& other);
      		 (9)(since C++11)
      (removed in C++17)
      template<class F,class Alloc>
      function(std::allocator_arg_t,const Alloc& alloc, F f);
      		 (10)(since C++11)
      (removed in C++17)

      Constructs astd::function from a variety of sources.

      1,2) Creates anemptystd::function.
      3) Copies thetarget ofother to the target of*this.
      Ifother is empty,*this will be empty right after the call too.
      4) Moves the target ofother to the target of*this.
      Ifother is empty,*this will be empty right after the call too.
      other is in a valid but unspecified state right after the call.
      5) Initializes the target withstd::forward<F>(f). The target is of typestd::decay<F>::type.
      Iff is a null pointer to function, a null pointer to member, or an empty value of somestd::function specialization,*this will be empty right after the call.
      This overload participates in overload resolution only if all following conditions are satisfied:
      (since C++23)
      • An lvalue of typestd::decay<F>::type is callable for argument typesArgs... and return typeR.

      Ifstd::is_copy_constructible_v<std::decay_t<F>> orstd::is_constructible_v<std::decay_t<F>, F> isfalse, the program is ill-formed.

      		(since C++23)
      IfF is notCopyConstructible, the behavior is undefined.
      6-10) Same as(1-5) except thatalloc is used to allocate memory for any internal data structures that thestd::function might use.

      When the target is a function pointer or astd::reference_wrapper, small object optimization is guaranteed, that is, these targets are always directly stored inside thestd::function object, no dynamic allocation takes place. Other large objects may be constructed in dynamic allocated storage and accessed by thestd::function object through a pointer.

      Contents

      [edit]Parameters

      other - the function object used to initialize*this
      f - a callable object used to initialize*this
      alloc - anAllocator used for internal memory allocation
      Type requirements
      -
      Alloc must meet the requirements ofAllocator.

      [edit]Exceptions

      3,8,9) Does not throw ifother's target is a function pointer or astd::reference_wrapper, otherwise may throwstd::bad_alloc or any exception thrown by the constructor used to copy or move the stored callable object.
      4) Does not throw ifother's target is a function pointer or astd::reference_wrapper, otherwise may throwstd::bad_alloc or any exception thrown by the constructor used to copy or move the stored callable object.
      		(until C++20)
      5,10) Does not throw iff is a function pointer or astd::reference_wrapper, otherwise may throwstd::bad_alloc or any exception thrown by the copy constructor of the stored callable object.

      [edit]Notes

      std::function's allocator support was poorly specified and inconsistently implemented. Some implementations do not provide overloads(6-10) at all, some provide the overloads but ignore the supplied allocator argument, and some provide the overloads and use the supplied allocator for construction but not when thestd::function is reassigned. As a result, allocator support was removed in C++17.

      [edit]Example

      Run this code
      #include <functional>#include <iostream>#include <utility> void print_num(int i){std::cout<<"print_num("<< i<<")\n";} int main(){std::function<void(int)> func1;// (1) empty constructortry{        func1(333<<1);}catch(conststd::bad_function_call& ex){std::cout<<"1) "<< ex.what()<<'\n';} std::function<void(int)> func2{nullptr};// (2) empty constructortry{        func1(222*3);}catch(conststd::bad_function_call& ex){std::cout<<"2) "<< ex.what()<<'\n';}     func1= print_num;// initializes func1 using assignment operator std::function<void(int)> func3{func1};// (3) copy constructor    func3(33); std::function<void(int)> func4{std::move(func3)};// (4) move constructor,// func3 in unspecified state    func4(44); std::function<void(int)> func5{print_num};// (5) constructor with function    func5(55); // (5) constructor with lambdastd::function<void(int)> func6([](int i){std::cout<<"lambda("<< i<<")\n";});    func6(66);}

      Possible output:

      1) bad_function_call2) bad_function_callprint_num(33)print_num(44)print_num(55)lambda(66)

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2132C++11overloads(5,10) might be ambiguousconstrained
      LWG 2774C++11(5,10) performed an additional moveeliminated

      [edit]See also

      constructs a newstd::move_only_function object
      (public member function ofstd::move_only_function)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/function/function&oldid=176891"
      [8]ページ先頭
      ©2009-2025 Movatter.jp