Home Original page

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

From cppreference.com

constexpr explicit indirect();

 (1) (since C++26)

constexpr explicit indirect( std::allocator_arg_t, const Allocator& a );

 (2) (since C++26)

template< class U = T > constexpr explicit indirect( U&& v );

 (3) (since C++26)

template< class U = T > constexpr explicit indirect( std::allocator_arg_t, const Allocator& a, U&& v );

 (4) (since C++26)

template< class... Args > constexpr explicit indirect( std::in_place_t, Args&&... args );

 (5) (since C++26)

template< class... Args > constexpr explicit indirect( std::allocator_arg_t, const Allocator& a, std::in_place_t, Args&&... args );

 (6) (since C++26)

template< class I, class... Args > constexpr explicit indirect( std::in_place_t, std::initializer_list<I> ilist, Args&&... args );

 (7) (since C++26)

template< class I, class... Args > constexpr explicit indirect( std::allocator_arg_t, const Allocator& a, std::in_place_t, std::initializer_list<I> ilist, Args&&... args );

 (8) (since C++26)

constexpr indirect( const indirect& other );

 (9) (since C++26)

constexpr indirect( std::allocator_arg_t, const Allocator& a, const indirect& other );

 (10) (since C++26)

constexpr indirect( indirect&& other ) noexcept;

 (11) (since C++26)

constexpr indirect( std::allocator_arg_t, const Allocator& a, indirect&& other ) noexcept(/* see below */);

 (12) (since C++26)

Constructs a new indirect 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 indirect object whose owned value (if exists) is copied

Effects

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

2) Constructs the owned object:

  • For overloads (1-8), initialize p with the result of calling std::allocator_traits<Allocator>::allocate, then calls std::allocator_traits<Allocator>::construct(alloc , p , args...), where 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.
 Overload  Initializer for... valueless_after_move()
after construction
alloc the owned object
(1) (empty) (empty) false
(2) a
(3) (empty) std::forward<U>(v)
(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) 		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 std::is_default_constructible_v<T> is false, the program is ill-formed.

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 std::is_constructible_v<T, /* argument types */> is true, 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 the following values are all false:

  • std::is_same_v<std::remove_cvref_t<U>, std::indirect>
  • std::is_same_v<std::remove_cvref_t<U>, std::in_place_t>

9,10) If std::is_copy_constructible_v<T> is false, the program is ill-formed.

11,12) When the construction completes, other is valueless.

12) If std::allocator_traits<Allocator>::is_always_equal::value is false and T is an incomplete type, the program is ill-formed.

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