RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../memory/uses_allocator_construction_args.html below:

std::uses_allocator_construction_args - cppreference.com

template< class T, class Alloc, class... Args > constexpr auto uses_allocator_construction_args( const Alloc& alloc, Args&&... args ) noexcept; (1) (since C++20) template< class T, class Alloc, class Tuple1, class Tuple2 > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::piecewise_construct_t, Tuple1&& x, Tuple2&& y ) noexcept; (2) (since C++20)

template< class T, class Alloc > constexpr auto uses_allocator_construction_args( const Alloc& alloc ) noexcept;

(3) (since C++20) template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, U&& u, V&& v ) noexcept; (4) (since C++20) template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>& pr ) noexcept; (5) (since C++23) template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, const std::pair<U, V>& pr ) noexcept; (6) (since C++20) template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>&& pr ) noexcept; (7) (since C++20) template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, const std::pair<U, V>&& pr ) noexcept; (8) (since C++23) template< class T, class Alloc, class NonPair > constexpr auto uses_allocator_construction_args( const Alloc& alloc, NonPair&& non_pair ) noexcept; (9) (since C++20)

Prepares the argument list needed to create an object of the given type T by means of uses-allocator construction.

1)

This overload participates in overload resolution only if

T

is not a specialization of

std::pair

. Returns

std::tuple

determined as follows:

If std::uses_allocator_v<T, Alloc> is false and std::is_constructible_v<T, Args...> is true, returns std::forward_as_tuple(std::forward<Args>(args)...).
Otherwise, if std::uses_allocator_v<T, Alloc> is true and std::is_constructible_v<T, std::allocator_arg_t, const Alloc&, Args...> is true, returns
std::tuple<std::allocator_arg_t, const Alloc&, Args&&...>(std::allocator_arg, alloc, std::forward<Args>(args)...).
Otherwise, if std::uses_allocator_v<T, Alloc> is true and std::is_constructible_v<T, Args..., const Alloc&> is true, returns std::forward_as_tuple(std::forward<Args>(args)..., alloc).
Otherwise, the program is ill-formed.

2)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

. For

T

that is

std::pair<T1, T2>

, equivalent to

3)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

. Equivalent to

4)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

. Equivalent to

5,6)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

. Equivalent to

7,8)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

. Equivalent to

9)

This overload participates in overload resolution only if

T

is a specialization of

std::pair

, and given the exposition-only function template

template<class A, class B>
void /*deduce-as-pair*/(const std::pair<A, B>&);

, /*deduce-as-pair*/(non_pair) is ill-formed when considered as an unevaluated operand.
Let the exposition-only class pair-constructor be defined as

This overload is equivalent to

return std::make_tuple(pair_construction);

, where

pair_construction

is a value of type

pair-constructor

whose

alloc_

and

u_

members are

alloc

and

non_pair

respectively.

[edit] Parameters alloc - the allocator to use args - the arguments to pass to T's constructor x - tuple of arguments to pass to the constructors of T's first data member y - tuple of arguments to pass to the constructors of T's second data member u - single argument to pass to the constructor of T's first data member v - single argument to pass to the constructor of T's second data member pr - a pair whose first data member will be passed to the constructor of T's first data member and second data member will be passed to the constructor of T's second data member non_pair - single argument to convert to a std::pair for further construction [edit] Return value

std::tuple of arguments suitable for passing to the constructor of T.

[edit] Notes

The overloads (2-9) provide allocator propagation into std::pair, which supports neither leading-allocator nor trailing-allocator calling conventions (unlike, e.g. std::tuple, which uses leading-allocator convention).

When used in uses-allocator construction, the conversion function of pair-constructor converts the provided argument to std::pair at first, and then constructs the result from that std::pair by uses-allocator construction.

[edit] Example [edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior LWG 3525 C++20 no overload could handle non-pair types convertible to pair reconstructing overload added [edit] See also

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4