[variant.ctor] - C++14 → C++17

Files changed (1) hide show

tmp/tmpa4v5iek8/{from.md → to.md} +210 -0

tmp/tmpa4v5iek8/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,210 @@

+#### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
+In the descriptions that follow, let i be in the range \[`0`,
+`sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types...`.
+``` cpp
+constexpr variant() noexcept(see below);
+```
+*Effects:* Constructs a `variant` holding a value-initialized value of
+type `T₀`.
+*Postconditions:* `valueless_by_exception()` is `false` and `index()` is
+`0`.
+*Throws:* Any exception thrown by the value-initialization of `T₀`.
+*Remarks:* This function shall be `constexpr` if and only if the
+value-initialization of the alternative type `T₀` would satisfy the
+requirements for a constexpr function. The expression inside `noexcept`
+is equivalent to `is_nothrow_default_constructible_v<``T₀``>`. This
+function shall not participate in overload resolution unless
+`is_default_constructible_v<``T₀``>` is `true`.
+[*Note 1*: See also class `monostate`. — *end note*]
+``` cpp
+variant(const variant& w);
+```
+*Effects:* If `w` holds a value, initializes the `variant` to hold the
+same alternative as `w` and direct-initializes the contained value with
+`get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
+`variant` to not hold a value.
+*Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
+i.
+*Remarks:* This function shall not participate in overload resolution
+unless `is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
+``` cpp
+variant(variant&& w) noexcept(see below);
+```
+*Effects:* If `w` holds a value, initializes the `variant` to hold the
+same alternative as `w` and direct-initializes the contained value with
+`get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
+the `variant` to not hold a value.
+*Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
+*Remarks:* The expression inside `noexcept` is equivalent to the logical
+AND of `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. This
+function shall not participate in overload resolution unless
+`is_move_constructible_v<``Tᵢ``>` is `true` for all i.
+``` cpp
+template <class T> constexpr variant(T&& t) noexcept(see below);
+```
+Let `Tⱼ` be a type that is determined as follows: build an imaginary
+function *FUN*(Tᵢ) for each alternative type `Tᵢ`. The overload
+*FUN*(Tⱼ) selected by overload resolution for the expression
+*FUN*(std::forward\<T\>(t)) defines the alternative `Tⱼ` which is the
+type of the contained value after construction.
+*Effects:* Initializes `*this` to hold the alternative type `Tⱼ` and
+direct-initializes the contained value as if
+direct-non-list-initializing it with `std::forward<T>(t)`.
+*Postconditions:* `holds_alternative<``Tⱼ``>(*this)` is `true`.
+*Throws:* Any exception thrown by the initialization of the selected
+alternative `Tⱼ`.
+*Remarks:* This function shall not participate in overload resolution
+unless `is_same_v<decay_t<T>, variant>` is `false`, unless `decay_t<T>`
+is neither a specialization of `in_place_type_t` nor a specialization of
+`in_place_index_t`, unless `is_constructible_v<``Tⱼ``, T>` is `true`,
+and unless the expression *FUN*(`std::forward<T>(t))` (with *FUN* being
+the above-mentioned set of imaginary functions) is well formed.
+[*Note 2*:
+``` cpp
+variant<string, string> v("abc");
+```
+is ill-formed, as both alternative types have an equally viable
+constructor for the argument.
+— *end note*]
+The expression inside `noexcept` is equivalent to
+`is_nothrow_constructible_v<``Tⱼ``, T>`. If `Tⱼ`’s selected constructor
+is a constexpr constructor, this constructor shall be a constexpr
+constructor.
+``` cpp
+template <class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T` with the arguments
+`std::forward<Args>(args)...`.
+*Postconditions:* `holds_alternative<T>(*this)` is `true`.
+*Throws:* Any exception thrown by calling the selected constructor of
+`T`.
+*Remarks:* This function shall not participate in overload resolution
+unless there is exactly one occurrence of `T` in `Types...` and
+`is_constructible_v<T, Args...>` is `true`. If `T`’s selected
+constructor is a constexpr constructor, this constructor shall be a
+constexpr constructor.
+``` cpp
+template <class T, class U, class... Args>
+  constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T` with the arguments
+`il, std::forward<Args>(args)...`.
+*Postconditions:* `holds_alternative<T>(*this)` is `true`.
+*Throws:* Any exception thrown by calling the selected constructor of
+`T`.
+*Remarks:* This function shall not participate in overload resolution
+unless there is exactly one occurrence of `T` in `Types...` and
+`is_constructible_v<T, initializer_list<U>&, Args...>` is `true`. If
+`T`’s selected constructor is a constexpr constructor, this constructor
+shall be a constexpr constructor.
+``` cpp
+template <size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`std::forward<Args>(args)...`.
+*Postconditions:* `index()` is `I`.
+*Throws:* Any exception thrown by calling the selected constructor of
+`T_I`.
+*Remarks:* This function shall not participate in overload resolution
+unless
+- `I` is less than `sizeof...(Types)` and
+- `is_constructible_v<``T_I``, Args...>` is `true`.
+If `T_I`’s selected constructor is a constexpr constructor, this
+constructor shall be a constexpr constructor.
+``` cpp
+template <size_t I, class U, class... Args>
+  constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T_I` with the arguments
+`il, std::forward<Args>(args)...`.
+*Postconditions:* `index()` is `I`.
+*Remarks:* This function shall not participate in overload resolution
+unless
+- `I` is less than `sizeof...(Types)` and
+- `is_constructible_v<``T_I``, initializer_list<U>&, Args...>` is
+  `true`.
+If `T_I`’s selected constructor is a constexpr constructor, this
+constructor shall be a constexpr constructor.
+``` cpp
+// allocator-extended constructors
+template <class Alloc>
+  variant(allocator_arg_t, const Alloc& a);
+template <class Alloc>
+  variant(allocator_arg_t, const Alloc& a, const variant& v);
+template <class Alloc>
+  variant(allocator_arg_t, const Alloc& a, variant&& v);
+template <class Alloc, class T>
+  variant(allocator_arg_t, const Alloc& a, T&& t);
+template <class Alloc, class T, class... Args>
+  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>, Args&&... args);
+template <class Alloc, class T, class U, class... Args>
+  variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>,
+          initializer_list<U> il, Args&&... args);
+template <class Alloc, size_t I, class... Args>
+  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>, Args&&... args);
+template <class Alloc, size_t I, class U, class... Args>
+  variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>,
+          initializer_list<U> il, Args&&... args);
+```
+*Requires:* `Alloc` shall meet the requirements for an
+Allocator ([[allocator.requirements]]).
+*Effects:* Equivalent to the preceding constructors except that the
+contained value is constructed with uses-allocator
+construction ([[allocator.uses.construction]]).

Diff to HTML by rtfpessoa