Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::make_unique,std::make_unique_for_overwrite

      From cppreference.com
      <cpp‎ |memory‎ |unique ptr
       
       
      Memory management library
      (exposition only*)
      Allocators
      Uninitialized memory algorithms
      Constrained uninitialized memory algorithms
      Memory resources
      Uninitialized storage(until C++20)
      (until C++20*)
      (until C++20*)
      Garbage collector support(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
       
       
      Defined in header<memory>
      (1)
      template<class T,class...Args>
      unique_ptr<T> make_unique( Args&&...args);
      		(since C++14)
      (until C++23)
      (only for non-array types)
      template<class T,class...Args>
      constexpr unique_ptr<T> make_unique( Args&&...args);
      		(since C++23)
      (only for non-array types)
      (2)
      template<class T>
      unique_ptr<T> make_unique(std::size_t size);
      		(since C++14)
      (until C++23)
      (only for array types with unknown bound)
      template<class T>
      constexpr unique_ptr<T> make_unique(std::size_t size);
      		(since C++23)
      (only for array types with unknown bound)
      template<class T,class...Args>
      /* unspecified */ make_unique( Args&&...args)= delete;
      		 (3)(since C++14)
      (only for array types with known bound)
      (4)
      template<class T>
      unique_ptr<T> make_unique_for_overwrite();
      		(since C++20)
      (until C++23)
      (only for non-array types)
      template<class T>
      constexpr unique_ptr<T> make_unique_for_overwrite();
      		(since C++23)
      (only for non-array types)
      (5)
      template<class T>
      unique_ptr<T> make_unique_for_overwrite(std::size_t size);
      		(since C++20)
      (until C++23)
      (only for array types with unknown bound)
      template<class T>
      constexpr unique_ptr<T> make_unique_for_overwrite(std::size_t size);
      		(since C++23)
      (only for array types with unknown bound)
      template<class T,class...Args>
      /* unspecified */ make_unique_for_overwrite( Args&&...args)= delete;
      		 (6)(since C++20)
      (only for array types with known bound)

      Constructs an object of typeT and wraps it in astd::unique_ptr.

      1) Constructs a non-array typeT. The argumentsargs are passed to the constructor ofT. This overload participates in overload resolution only ifT is not an array type. The function is equivalent to:
      unique_ptr<T>(new T(std::forward<Args>(args)...))
      2) Constructs an array of the given dynamic size. The array elements arevalue-initialized. This overload participates in overload resolution only ifT is an array of unknown bound. The function is equivalent to:
      unique_ptr<T>(newstd::remove_extent_t<T>[size]())
      3,6) Construction of arrays of known bound is disallowed.
      4) Same as(1), except that the object isdefault-initialized. This overload participates in overload resolution only ifT is not an array type. The function is equivalent to:
      unique_ptr<T>(new T)
      5) Same as(2), except that the array is default-initialized. This overload participates in overload resolution only ifT is an array of unknown bound. The function is equivalent to:
      unique_ptr<T>(newstd::remove_extent_t<T>[size])

      Contents

      [edit]Parameters

      args - list of arguments with which an instance ofT will be constructed
      size - the length of the array to construct

      [edit]Return value

      std::unique_ptr of an instance of typeT.

      [edit]Exceptions

      May throwstd::bad_alloc or any exception thrown by the constructor ofT. If an exception is thrown, this function has no effect.

      [edit]Possible Implementation

      make_unique(1-3)
      // C++14 make_uniquenamespace detail{template<class>constexprbool is_unbounded_array_v=false;template<class T>constexprbool is_unbounded_array_v<T[]>=true; template<class>constexprbool is_bounded_array_v=false;template<class T,std::size_t N>constexprbool is_bounded_array_v<T[N]>=true;}// namespace detail template<class T,class...Args>std::enable_if_t<!std::is_array<T>::value,std::unique_ptr<T>>make_unique(Args&&...args){returnstd::unique_ptr<T>(new T(std::forward<Args>(args)...));} template<class T>std::enable_if_t<detail::is_unbounded_array_v<T>,std::unique_ptr<T>>make_unique(std::size_t n){returnstd::unique_ptr<T>(newstd::remove_extent_t<T>[n]());} template<class T,class...Args>std::enable_if_t<detail::is_bounded_array_v<T>> make_unique(Args&&...)= delete;
      make_unique_for_overwrite(4-6)
      // C++20 make_unique_for_overwritetemplate<class T>    requires(!std::is_array_v<T>)std::unique_ptr<T> make_unique_for_overwrite(){returnstd::unique_ptr<T>(new T);} template<class T>    requiresstd::is_unbounded_array_v<T>std::unique_ptr<T> make_unique_for_overwrite(std::size_t n){returnstd::unique_ptr<T>(newstd::remove_extent_t<T>[n]);} template<class T,class...Args>    requiresstd::is_bounded_array_v<T>void make_unique_for_overwrite(Args&&...)= delete;

      [edit]Notes

      Unlikestd::make_shared (which hasstd::allocate_shared),std::make_unique does not have an allocator-aware counterpart.allocate_unique proposed inP0211 would be required to invent the deleter typeD for thestd::unique_ptr<T,D> it returns which would contain an allocator object and invoke bothdestroy anddeallocate in itsoperator().

      Feature-test macroValueStdFeature
      __cpp_lib_make_unique201304L(C++14)std::make_unique; overload(1)
      __cpp_lib_smart_ptr_for_overwrite202002L(C++20)Smart pointer creation with default initialization (std::allocate_shared_for_overwrite,std::make_shared_for_overwrite,std::make_unique_for_overwrite); overloads(4-6)
      __cpp_lib_constexpr_memory202202L(C++23)constexpr for overloads(1,2,4,5)

      [edit]Example

      This section is incomplete
      Reason: add moremake_unique_for_overwrite() demos
      Run this code
      #include <cstddef>#include <iomanip>#include <iostream>#include <memory>#include <utility> struct Vec3{int x, y, z; // Following constructor is no longer needed since C++20.    Vec3(int x=0,int y=0,int z=0)noexcept: x(x), y(y), z(z){} friendstd::ostream& operator<<(std::ostream& os,const Vec3& v){return os<<"{ x="<< v.x<<", y="<< v.y<<", z="<< v.z<<" }";}}; // Output Fibonacci numbers to an output iterator.template<typename OutputIt>OutputIt fibonacci(OutputIt first, OutputIt last){for(int a=0, b=1; first!= last;++first){*first= b;        b+=std::exchange(a, b);}return first;} int main(){// Use the default constructor.std::unique_ptr<Vec3> v1= std::make_unique<Vec3>();// Use the constructor that matches these arguments.std::unique_ptr<Vec3> v2= std::make_unique<Vec3>(0,1,2);// Create a unique_ptr to an array of 5 elements.std::unique_ptr<Vec3[]> v3= std::make_unique<Vec3[]>(5); // Create a unique_ptr to an uninitialized array of 10 integers,// then populate it with Fibonacci numbers.std::unique_ptr<int[]> i1= std::make_unique_for_overwrite<int[]>(10);    fibonacci(i1.get(), i1.get()+10); std::cout<<"make_unique<Vec3>():      "<<*v1<<'\n'<<"make_unique<Vec3>(0,1,2): "<<*v2<<'\n'<<"make_unique<Vec3[]>(5):   ";for(std::size_t i=0; i<5;++i)std::cout<<std::setw(i?30:0)<< v3[i]<<'\n';std::cout<<'\n'; std::cout<<"make_unique_for_overwrite<int[]>(10), fibonacci(...): ["<< i1[0];for(std::size_t i=1; i<10;++i)std::cout<<", "<< i1[i];std::cout<<"]\n";}

      Output:

      make_unique<Vec3>():      { x=0, y=0, z=0 }make_unique<Vec3>(0,1,2): { x=0, y=1, z=2 }make_unique<Vec3[]>(5):   { x=0, y=0, z=0 }                          { x=0, y=0, z=0 }                          { x=0, y=0, z=0 }                          { x=0, y=0, z=0 }                          { x=0, y=0, z=0 } make_unique_for_overwrite<int[]>(10), fibonacci(...): [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

      [edit]See also

      constructs a newunique_ptr
      (public member function)[edit]
      creates a shared pointer that manages a new object
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/unique_ptr/make_unique&oldid=160470"
      [8]ページ先頭
      ©2009-2025 Movatter.jp