[pairs] - C++11 → C++14

Files changed (1) hide show

tmp/tmp1tqp8ndd/{from.md → to.md} +81 -32

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

@@ -22,14 +22,14 @@ namespace std {
     T1 first;
     T2 second;
     pair(const pair&) = default;
     pair(pair&&) = default;
     constexpr pair();
-    pair(const T1& x, const T2& y);
-    template<class U, class V> pair(U&& x, V&& y);
-    template<class U, class V> pair(const pair<U, V>& p);
-    template<class U, class V> 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);
@@ -40,14 +40,19 @@ namespace std {
     void swap(pair& p) noexcept(see below);
   };
 }
 ```
-Constructors and member function of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
 ``` cpp
 constexpr pair();
 ```
 *Requires:* `is_default_constructible<first_type>::value` is `true` and
@@ -55,21 +60,21 @@ constexpr pair();
 `ible<second_type>::value` is `true`.
 *Effects:* Value-initializes `first` and `second`.
 ``` cpp
-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> pair(U&& x, V&& y);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
@@ -79,11 +84,11 @@ 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> 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`.
@@ -93,11 +98,11 @@ 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> pair(pair<U, V>&& p);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
@@ -113,13 +118,12 @@ convertible to `second_type`.
 template<class... Args1, class... Args2>
   pair(piecewise_construct_t,
        tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
-*Requires:* *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
@@ -141,12 +145,12 @@ pair& operator=(const pair& p);
 ``` 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`.
@@ -202,47 +206,47 @@ swappable with `p.second`.
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
 template <class T1, class T2>
-  bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template <class T1, class T2>
-  bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:*
 `x.first < y.first || (!(y.first < x.first) && x.second < y.second)`.
 ``` cpp
 template <class T1, class T2>
-  bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x == y)`
 ``` cpp
 template <class T1, class T2>
-  bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `y < x`
 ``` cpp
 template <class T1, class T2>
-  bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x < y)`
 ``` cpp
 template <class T1, class T2>
-  bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(y < x)`
 ``` cpp
@@ -252,17 +256,17 @@ template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y)
 *Effects:* `x.swap(y)`
 ``` cpp
 template <class T1, class T2>
-  pair<V1, V2> make_pair(T1&& x, T2&& y);
 ```
 *Returns:* `pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))`;
-where `V1` and `V2` are determined as follows: Let `Ui` be
-`decay<Ti>::type` for each `Ti`. Then each `Vi` is `X&` if `Ui` equals
 `reference_wrapper<X>`, otherwise `Vi` is `Ui`.
 In place of:
 ``` cpp
@@ -276,17 +280,15 @@ return make_pair(5, 3.1415926);           // types are deduced
 ```
 ### Tuple-like access to pair <a id="pair.astuple">[[pair.astuple]]</a>
 ``` cpp
-tuple_size<pair<T1, T2> >::value
 ```
-*Returns:* Integral constant expression.
-*Value:* 2.
 ``` cpp
 tuple_element<0, pair<T1, T2> >::type
 ```
 *Value:* the type `T1`.
@@ -297,32 +299,79 @@ tuple_element<1, pair<T1, T2> >::type
 *Value:* the type T2.
 ``` cpp
 template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type& get(pair<T1, T2>&) noexcept;
 template<size_t I, class T1, class T2>
-  const typename tuple_element<I, std::pair<T1, T2> >::type& get(const pair<T1, T2>&) noexcept;
 ```
 *Returns:* If `I == 0` returns `p.first`; if `I == 1` returns
 `p.second`; otherwise the program is ill-formed.
 ``` cpp
 template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type&& get(std::pair<T1, T2>&&) noexcept;
 ```
 *Returns:* If `I == 0` returns `std::forward<T1&&>(p.first)`; if
 `I == 1` returns `std::forward<T2&&>(p.second)`; otherwise the program
 is ill-formed.
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
 ``` cpp
 struct piecewise_construct_t { };
-constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 ```
 The `struct` `piecewise_construct_t` is an empty structure type used as
 a unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as

     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);
     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
 `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`.
 *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`.
 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`.
 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
 ``` 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`.
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:*
 `x.first < y.first || (!(y.first < x.first) && x.second < y.second)`.
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x == y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `y < x`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x < y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(y < x)`
 ``` cpp
 *Effects:* `x.swap(y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr pair<V1, V2> make_pair(T1&& x, T2&& y);
 ```
 *Returns:* `pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))`;
+where `V1` and `V2` are determined as follows: Let `Ui` be `decay_t<Ti>`
+for each `Ti`. Then each `Vi` is `X&` if `Ui` equals
 `reference_wrapper<X>`, otherwise `Vi` is `Ui`.
 In place of:
 ``` cpp
 ```
 ### Tuple-like access to pair <a id="pair.astuple">[[pair.astuple]]</a>
 ``` cpp
+template <class T1, class T2>
+struct tuple_size<pair<T1, T2>>
+  : integral_constant<size_t, 2> { };
 ```
 ``` cpp
 tuple_element<0, pair<T1, T2> >::type
 ```
 *Value:* the type `T1`.
 *Value:* the type T2.
 ``` cpp
 template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&
+    get(pair<T1, T2>& p) noexcept;
 template<size_t I, class T1, class T2>
+ constexpr const tuple_element_t<I, pair<T1, T2>>&
+    get(const pair<T1, T2>& p) noexcept;
 ```
 *Returns:* If `I == 0` returns `p.first`; if `I == 1` returns
 `p.second`; otherwise the program is ill-formed.
 ``` cpp
 template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&&
+    get(pair<T1, T2>&& p) noexcept;
 ```
 *Returns:* If `I == 0` returns `std::forward<T1&&>(p.first)`; if
 `I == 1` returns `std::forward<T2&&>(p.second)`; otherwise the program
 is ill-formed.
+``` cpp
+template <class T, class U>
+  constexpr T& get(pair<T, U>& p) noexcept;
+template <class T, class U>
+  constexpr const T& get(const pair<T, U>& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<0>(p);`
+``` cpp
+template <class T, class U>
+  constexpr T&& get(pair<T, U>&& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<0>(std::move(p));`
+``` cpp
+template <class T, class U>
+  constexpr T& get(pair<U, T>& p) noexcept;
+template <class T, class U>
+  constexpr const T& get(const pair<U, T>& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<1>(p);`
+``` cpp
+template <class T, class U>
+  constexpr T&& get(pair<U, T>&& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<1>(std::move(p));`
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
 ``` cpp
 struct piecewise_construct_t { };
+constexpr piecewise_construct_t piecewise_construct{};
 ```
 The `struct` `piecewise_construct_t` is an empty structure type used as
 a unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as

Diff to HTML by rtfpessoa