[pairs.pair] - C++14 → C++17

Files changed (1) hide show

tmp/tmplc8bcp8e/{from.md → to.md} +106 -92

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

@@ -1,196 +1,210 @@
 ### Class template `pair` <a id="pairs.pair">[[pairs.pair]]</a>
 ``` cpp
-// defined in header <utility>
 namespace std {
   template <class T1, class T2>
     struct pair {
-    typedef T1 first_type;
-    typedef T2 second_type;
       T1 first;
       T2 second;
       pair(const pair&) = default;
       pair(pair&&) = default;
- constexpr pair();
- constexpr pair(const T1& x, const T2& y);
- template<class U, class V> constexpr pair(U&& x, V&& y);
- template<class U, class V> constexpr pair(const pair<U, V>& p);
- template<class U, class V> constexpr pair(pair<U, V>&& p);
       template <class... Args1, class... Args2>
- pair(piecewise_construct_t,
-           tuple<Args1...> first_args, tuple<Args2...> second_args);
       pair& operator=(const pair& p);
- template<class U, class V> pair& operator=(const pair<U, V>& p);
       pair& operator=(pair&& p) noexcept(see below);
- template<class U, class V> pair& operator=(pair<U, V>&& p);
       void swap(pair& p) noexcept(see below);
     };
 }
 ```
 Constructors and member functions of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
-The defaulted move and copy constructor, respectively, of pair shall be
-a `constexpr` function if and only if all required element-wise
 initializations for copy and move, respectively, would satisfy the
-requirements for a `constexpr` function.
 ``` cpp
-constexpr pair();
 ```
-*Requires:* `is_default_constructible<first_type>::value` is `true` and
-`is_default_construct-`
-`ible<second_type>::value` is `true`.
 *Effects:* Value-initializes `first` and `second`.
 ``` cpp
-constexpr pair(const T1& x, const T2& y);
 ```
-*Requires:* `is_copy_constructible<first_type>::value` is `true` and
-`is_copy_constructible<second_type>::value` is `true`.
-*Effects:* The constructor initializes `first` with `x` and `second`
-with `y`.
 ``` cpp
-template<class U, class V> constexpr pair(U&& x, V&& y);
 ```
-*Requires:* `is_constructible<first_type, U&&>::value` is `true` and
-`is_constructible<second_type, V&&>::value` is `true`.
-*Effects:* The constructor initializes `first` with `std::forward<U>(x)`
-and `second` with `std::forward<V>(y)`.
-*Remarks:* If `U` is not implicitly convertible to `first_type` or `V`
-is not implicitly convertible to `second_type` this constructor shall
-not participate in overload resolution.
 ``` cpp
-template<class U, class V> constexpr pair(const pair<U, V>& p);
 ```
-*Requires:* `is_constructible<first_type, const U&>::value` is `true`
-and `is_constructible<second_type, const V&>::value` is `true`.
 *Effects:* Initializes members from the corresponding members of the
 argument.
-This constructor shall not participate in overload resolution unless
-`const U&` is implicitly convertible to `first_type` and `const V&` is
-implicitly convertible to `second_type`.
 ``` cpp
-template<class U, class V> constexpr pair(pair<U, V>&& p);
 ```
-*Requires:* `is_constructible<first_type, U&&>::value` is `true` and
-`is_constructible<second_type, V&&>::value` is `true`.
-*Effects:* The constructor initializes `first` with
-`std::forward<U>(p.first)` and `second` with
-`std::forward<V>(p.second)`.
-This constructor shall not participate in overload resolution unless `U`
-is implicitly convertible to `first_type` and `V` is implicitly
-convertible to `second_type`.
 ``` cpp
 template<class... Args1, class... Args2>
-  pair(piecewise_construct_t,
-       tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
-*Requires:* `is_constructible<first_type, Args1&&...>::value` is `true`
-and `is_constructible<second_type, Args2&&...>::value` is `true`.
-*Effects:* The constructor initializes `first` with arguments of types
-`Args1...` obtained by forwarding the elements of `first_args` and
-initializes `second` with arguments of types `Args2...` obtained by
-forwarding the elements of `second_args`. (Here, forwarding an element
-`x` of type `U` within a `tuple` object means calling
-`std::forward<U>(x)`.) This form of construction, whereby constructor
-arguments for `first` and `second` are each provided in a separate
-`tuple` object, is called *piecewise construction*.
 ``` cpp
 pair& operator=(const pair& p);
 ```
-*Requires:* `is_copy_assignable<first_type>::value` is `true` and
-`is_copy_assignable<second_type>::value` is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 ``` cpp
-template<class U, class V> pair& operator=(const pair<U, V>& p);
 ```
-*Requires:* `is_assignable<first_type&, const U&>::value` is `true` and
-`is_assignable<second_type&, const V&>::value` is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 ``` cpp
 pair& operator=(pair&& p) noexcept(see below);
 ```
-*Remarks:* The expression inside `noexcept` is equivalent to:
-``` cpp
-is_nothrow_move_assignable<T1>::value &&
-is_nothrow_move_assignable<T2>::value
-```
-*Requires:* `is_move_assignable<first_type>::value` is `true` and
-`is_move_assignable<second_type>::value` is `true`.
 *Effects:* Assigns to `first` with `std::forward<first_type>(p.first)`
 and to `second` with
 `std::forward<second_type>(p.second)`.
 *Returns:* `*this`.
 ``` cpp
-template<class U, class V> pair& operator=(pair<U, V>&& p);
 ```
-*Requires:* `is_assignable<first_type&, U&&>::value` is `true` and
-`is_assignable<second_type&, V&&>::value` is `true`.
 *Effects:* Assigns to `first` with `std::forward<U>(p.first)` and to
 `second` with
 `std::forward<V>(p.second)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(pair& p) noexcept(see below);
 ```
-*Remarks:* The expression inside `noexcept` is equivalent to:
-``` cpp
-noexcept(swap(first, p.first)) &&
-noexcept(swap(second, p.second))
-```
 *Requires:* `first` shall be swappable
 with ([[swappable.requirements]]) `p.first` and `second` shall be
 swappable with `p.second`.
 *Effects:* Swaps `first` with `p.first` and `second` with `p.second`.

 ### Class template `pair` <a id="pairs.pair">[[pairs.pair]]</a>
 ``` cpp
 namespace std {
   template <class T1, class T2>
     struct pair {
+      using first_type  = T1;
+      using second_type = T2;
       T1 first;
       T2 second;
       pair(const pair&) = default;
       pair(pair&&) = default;
+      \EXPLICIT constexpr pair();
+      \EXPLICIT constexpr pair(const T1& x, const T2& y);
+ template<class U1, class U2> \EXPLICIT constexpr pair(U1&& x, U2&& y);
+ template<class U1, class U2> \EXPLICIT constexpr pair(const pair<U1, U2>& p);
+ template<class U1, class U2> \EXPLICIT constexpr pair(pair<U1, U2>&& p);
       template <class... Args1, class... Args2>
+ pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args);
       pair& operator=(const pair& p);
+ template<class U1, class U2> pair& operator=(const pair<U1, U2>& p);
       pair& operator=(pair&& p) noexcept(see below);
+ template<class U1, class U2> pair& operator=(pair<U1, U2>&& p);
       void swap(pair& p) noexcept(see below);
     };
+  template<class T1, class T2>
+    pair(T1, T2) -> pair<T1, T2>;
 }
 ```
 Constructors and member functions of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
+The defaulted move and copy constructor, respectively, of `pair` shall
+be a constexpr function if and only if all required element-wise
 initializations for copy and move, respectively, would satisfy the
+requirements for a constexpr function. The destructor of `pair` shall be
+a trivial destructor if
+`(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
+is `true`.
 ``` cpp
+\EXPLICIT constexpr pair();
 ```
 *Effects:* Value-initializes `first` and `second`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_default_constructible_v<first_type>` is `true` and
+`is_default_constructible_v<second_type>` is `true`.
+[*Note 1*: This behavior can be implemented by a constructor template
+with default template arguments. — *end note*]
+The constructor is explicit if and only if either `first_type` or
+`second_type` is not implicitly default-constructible.
+[*Note 2*: This behavior can be implemented with a trait that checks
+whether a `const first_type&` or a `const second_type&` can be
+initialized with `{}`. — *end note*]
 ``` cpp
+\EXPLICIT constexpr pair(const T1& x, const T2& y);
 ```
+*Effects:* Initializes `first` with `x` and `second` with `y`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_copy_constructible_v<first_type>` is `true` and
+`is_copy_constructible_v<second_type>` is `true`. The constructor is
+explicit if and only if
+`is_convertible_v<const first_type&, first_type>` is `false` or
+`is_convertible_v<const second_type&, second_type>` is `false`.
 ``` cpp
+template<class U1, class U2> \EXPLICIT constexpr pair(U1&& x, U2&& y);
 ```
+*Effects:* Initializes `first` with `std::forward<U1>(x)` and `second`
+with `std::forward<U2>(y)`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<first_type, U1&&>` is `true` and
+`is_constructible_v<second_type, U2&&>` is `true`. The constructor is
+explicit if and only if `is_convertible_v<U1&&, first_type>` is `false`
+or `is_convertible_v<U2&&, second_type>` is `false`.
 ``` cpp
+template<class U1, class U2> \EXPLICIT constexpr pair(const pair<U1, U2>& p);
 ```
 *Effects:* Initializes members from the corresponding members of the
 argument.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<first_type, const U1&>` is `true` and
+`is_constructible_v<second_type, const U2&>` is `true`. The constructor
+is explicit if and only if `is_convertible_v<const U1&, first_type>` is
+`false` or `is_convertible_v<const U2&, second_type>` is `false`.
 ``` cpp
+template<class U1, class U2> \EXPLICIT constexpr pair(pair<U1, U2>&& p);
 ```
+*Effects:* Initializes `first` with `std::forward<U1>(p.first)` and
+`second` with `std::forward<U2>(p.second)`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<first_type, U1&&>` is `true` and
+`is_constructible_v<second_type, U2&&>` is `true`. The constructor is
+explicit if and only if `is_convertible_v<U1&&, first_type>` is `false`
+or `is_convertible_v<U2&&, second_type>` is `false`.
 ``` cpp
 template<class... Args1, class... Args2>
+  pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
+*Requires:* `is_constructible_v<first_type, Args1&&...>` is `true` and
+`is_constructible_v<second_type, Args2&&...>` is `true`.
+*Effects:* Initializes `first` with arguments of types `Args1...`
+obtained by forwarding the elements of `first_args` and initializes
+`second` with arguments of types `Args2...` obtained by forwarding the
+elements of `second_args`. (Here, forwarding an element `x` of type `U`
+within a `tuple` object means calling `std::forward<U>(x)`.) This form
+of construction, whereby constructor arguments for `first` and `second`
+are each provided in a separate `tuple` object, is called *piecewise
+construction*.
 ``` cpp
 pair& operator=(const pair& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
+*Remarks:* This operator shall be defined as deleted unless
+`is_copy_assignable_v<first_type>` is `true` and
+`is_copy_assignable_v<second_type>` is `true`.
 *Returns:* `*this`.
 ``` cpp
+template<class U1, class U2> pair& operator=(const pair<U1, U2>& p);
 ```
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
+*Remarks:* This operator shall not participate in overload resolution
+unless `is_assignable_v<first_type&, const U1&>` is `true` and
+`is_assignable_v<second_type&, const U2&>` is `true`.
 *Returns:* `*this`.
 ``` cpp
 pair& operator=(pair&& p) noexcept(see below);
 ```
 *Effects:* Assigns to `first` with `std::forward<first_type>(p.first)`
 and to `second` with
 `std::forward<second_type>(p.second)`.
+*Remarks:* This operator shall be defined as deleted unless
+`is_move_assignable_v<first_type>` is `true` and
+`is_move_assignable_v<second_type>` is `true`.
+*Remarks:* The expression inside `noexcept` is equivalent to:
+``` cpp
+is_nothrow_move_assignable_v<T1> && is_nothrow_move_assignable_v<T2>
+```
 *Returns:* `*this`.
 ``` cpp
+template<class U1, class U2> pair& operator=(pair<U1, U2>&& p);
 ```
 *Effects:* Assigns to `first` with `std::forward<U>(p.first)` and to
 `second` with
 `std::forward<V>(p.second)`.
+*Remarks:* This operator shall not participate in overload resolution
+unless `is_assignable_v<first_type&, U1&&>` is `true` and
+`is_assignable_v<second_type&, U2&&>` is `true`.
 *Returns:* `*this`.
 ``` cpp
 void swap(pair& p) noexcept(see below);
 ```
 *Requires:* `first` shall be swappable
 with ([[swappable.requirements]]) `p.first` and `second` shall be
 swappable with `p.second`.
 *Effects:* Swaps `first` with `p.first` and `second` with `p.second`.
+*Remarks:* The expression inside `noexcept` is equivalent to:
+``` cpp
+is_nothrow_swappable_v<first_type> && is_nothrow_swappable_v<second_type>
+```

Diff to HTML by rtfpessoa