|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Member functions | ||||
| Modifiers | ||||
| Observers | ||||
| Non-member functions | ||||
make_uniquemake_unique_for_overwrite (C++14)(C++20) | ||||
(until C++20)(C++20) | ||||
(C++20) | ||||
| Helper classes | ||||
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.
T. 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)...))
T is an array of unknown bound. The function is equivalent to:unique_ptr<T>(newstd::remove_extent_t<T>[size]())
T is not an array type. The function is equivalent to:unique_ptr<T>(new T)
T is an array of unknown bound. The function is equivalent to:unique_ptr<T>(newstd::remove_extent_t<T>[size])
Contents |
| args | - | list of arguments with which an instance ofT will be constructed |
| size | - | the length of the array to construct |
std::unique_ptr of an instance of typeT.
May throwstd::bad_alloc or any exception thrown by the constructor ofT. If an exception is thrown, this function has no effect.
| 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; |
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 macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_make_unique | 201304L | (C++14) | std::make_unique; overload(1) |
__cpp_lib_smart_ptr_for_overwrite | 202002L | (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_memory | 202202L | (C++23) | constexpr for overloads(1,2,4,5) |
| This section is incomplete Reason: add moremake_unique_for_overwrite() demos |
#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] constructs a newunique_ptr(public member function)[edit] | |
| creates a shared pointer that manages a new object (function template)[edit] |
