std::polymorphic<T, Allocator>::polymorphic - cppreference.com (original) (raw)

constexpr explicit polymorphic();	(1)	(since C++26)
constexpr explicit polymorphic( std::allocator_arg_t, const Allocator& a );	(2)	(since C++26)
template< class U = T > constexpr explicit polymorphic( U&& v );	(3)	(since C++26)
template< class U = T > constexpr explicit polymorphic( std::allocator_arg_t, const Allocator& a, U&& v );	(4)	(since C++26)
template< class U, class... Args > constexpr explicit polymorphic( std::in_place_type_t<U>, Args&&... args );	(5)	(since C++26)
template< class U, class... Args > constexpr explicit polymorphic( std::allocator_arg_t, const Allocator& a, std::in_place_type_t<U>, Args&&... args );	(6)	(since C++26)
template< class U, class I, class... Args > constexpr explicit polymorphic( std::in_place_type_t<U>, std::initializer_list<I> ilist, Args&&... args );	(7)	(since C++26)
template< class U, class I, class... Args > constexpr explicit polymorphic( std::allocator_arg_t, const Allocator& a, std::in_place_type_t<U>, std::initializer_list<I> ilist, Args&&... args );	(8)	(since C++26)
constexpr polymorphic( const polymorphic& other );	(9)	(since C++26)
constexpr polymorphic( std::allocator_arg_t, const Allocator& a, const polymorphic& other );	(10)	(since C++26)
constexpr polymorphic( polymorphic&& other ) noexcept;	(11)	(since C++26)
constexpr polymorphic( std::allocator_arg_t, const Allocator& a, polymorphic&& other ) noexcept(/* see below */);	(12)	(since C++26)

Constructs a new polymorphic object.

a	-	the allocator to be associated
v	-	value with which to initialize the owned value
args	-	arguments with which to initialize the owned value
il	-	initializer list with which to initialize the owned value
other	-	another polymorphic object whose owned value (if exists) is copied

The construction of a new polymorphic object consists of the following steps:

For overloads (1-8), calls std::allocator_traits<Allocator>::construct(_[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ , p, args...), where
- p is a pointer of type U*, it points to storage suitable for the owned object to be constructed, and
- args... is an expression pack containing the initializer arguments.
For overloads (9-12):
- If other is valueless, no owned object is constructed, and *this is also valueless after construction.
- Otherwise, if other is an rvalue reference and _[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ equals other._[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_, *this takes ownership of the owned object of other.
- Otherwise, the owned object is constructed using _[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ as described above, where the type of p is determined by the type of the object owned by other.

Overload	Initializer for...	Type of the owned object	valueless_after_move()after construction
alloc	the owned object
(1)	(empty)	(empty)	T	false
(2)	a
(3)	(empty)	std::forward<U>(v)	U
(4)	a
(5)	(empty)	std::forward<Args>(args)
(6)	a
(7)	(empty)	ilist, std::forward<Args>(args)
(8)	a
(9)	see below	*other(only if other owns a value)	the type of the object owned by other	true only if other is valueless
(10)	a
(11)	std::move (other.alloc )	takes ownership(only if other owns a value)
(12)	a	see below

_[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ is direct-non-list-initialized with std::allocator_traits<Allocator>::
``select_on_container_copy_construction(other._[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ ).
The owned object is constructed as follows:

If other is valueless, *this is also valueless.
Otherwise, if alloc == other._[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ is true, *this takes ownership of the owned object of other.
Otherwise, constructs an owned object with *std::move(other) using _[alloc](../polymorphic.html#alloc "cpp/memory/polymorphic")_ .

3,4) U

5,6) Args...

Throws nothing unless std::allocator_traits<Allocator>::allocate or std::allocator_traits<Allocator>::construct throws.

Contents