Home Original page

std::polymorphic<T, Allocator>::polymorphic - cppreference.com

From cppreference.com

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.

Parameters

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

Effects

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

2) Constructs the owned object:

  • For overloads (1-8), calls std::allocator_traits<Allocator>::construct(alloc , 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 equals other.alloc, *this takes ownership of the owned object of other.
    • Otherwise, the owned object is constructed using alloc 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

9) alloc is direct-non-list-initialized with std::allocator_traits<Allocator>::
    select_on_container_copy_construction(other.alloc ).

12) The owned object is constructed as follows:

  • If other is valueless, *this is also valueless.
  • Otherwise, if alloc == other.alloc is true, *this takes ownership of the owned object of other.
  • Otherwise, constructs an owned object with *std::move(other) using alloc .

Constraints and supplement information

1,2) If any of the following values is false, the program is ill-formed:

  • std::is_default_constructible_v<T>
  • std::is_copy_constructible_v<T>

1) This overload participates in overload resolution only if std::is_default_constructible_v<Allocator> is true.

3-8) These overloads participate in overload resolution only if the following values are all true:

  • std::derived_from<std::remove_cvref_t<U>, T>
  • std::is_copy_constructible_v<std::remove_cvref_t<U>>
  • std::is_constructible_v<std::remove_cvref_t<U>, /* argument types */>, where /* argument types */ are:

3,4) U

5,6) Args...

7,8) std::initializer_list<I>&, Args...

3,5,7) These overloads participate in overload resolution only if std::is_default_constructible_v<Allocator> is true.

3,4) These overloads participate in overload resolution only if all following conditions are satisfied:

  • std::is_same_v<std::remove_cvref_t<U>, std::polymorphic> is false.
  • U is not a specialization of std::in_place_type_t.

5-8) These overloads participate in overload resolution only if std::is_same_v<std::remove_cvref_t<U>, U> is true.

Exceptions

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

12)

noexcept

specification:

noexcept(std::allocator_traits<Allocator>::is_always_equal::value)

Example

See also