[time.duration] - C++11 → C++14

Files changed (1) hide show

tmp/tmpv4fhy5x_/{from.md → to.md} +88 -11

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

@@ -63,10 +63,15 @@ is ill-formed.
 *Remarks:* If `Period::num` is not positive, the program is ill-formed.
 *Requires:* Members of `duration` shall not throw exceptions other than
 those thrown by the indicated operations on their representations.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
@@ -98,11 +103,12 @@ duration<int, milli> d(3.5);        // error
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
-unless `treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
 `treat_as_floating_point<Rep2>::value` is `false`. This requirement
 prevents implicit truncation error when converting between
 integral-based `duration` types. Such a construction could easily lead
 to confusion about the value of the `duration`.
@@ -236,53 +242,53 @@ static constexpr duration max();
 *Returns:* `duration(duration_values<rep>::max())`.
 #### `duration` non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
 In the function descriptions that follow, `CD` represents the return
-type of the function. `CR(A,B)` represents `common_type<A, B>::type`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep1` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* `d * s`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
@@ -290,19 +296,19 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<Rep1, Rep2>::type
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `CD(lhs).count() / CD(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
@@ -310,20 +316,20 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
-`common_type<A, B>::type`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
@@ -405,5 +411,76 @@ conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
 the final step.

 *Remarks:* If `Period::num` is not positive, the program is ill-formed.
 *Requires:* Members of `duration` shall not throw exceptions other than
 those thrown by the indicated operations on their representations.
+*Remarks:* The defaulted copy constructor of duration shall be a
+`constexpr` function if and only if the required initialization of the
+member `rep_` for copy and move, respectively, would satisfy the
+requirements for a `constexpr` function.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
+unless no overflow is induced in the conversion and
+`treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
 `treat_as_floating_point<Rep2>::value` is `false`. This requirement
 prevents implicit truncation error when converting between
 integral-based `duration` types. Such a construction could easily lead
 to confusion about the value of the `duration`.
 *Returns:* `duration(duration_values<rep>::max())`.
 #### `duration` non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
 In the function descriptions that follow, `CD` represents the return
+type of the function. `CR(A,B)` represents `common_type_t<A, B>`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep1` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* `d * s`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
 *Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `CD(lhs).count() / CD(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
 *Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
+`common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
 the final step.
+#### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
+This section describes literal suffixes for constructing duration
+literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
+values of the corresponding types `hours`, `minutes`, `seconds`,
+`milliseconds`, `microseconds`, and `nanoseconds` respectively if they
+are applied to integral literals.
+If any of these suffixes are applied to a floating point literal the
+result is a `chrono::duration` literal with an unspecified floating
+point representation.
+If any of these suffixes are applied to an integer literal and the
+resulting `chrono::duration` value cannot be represented in the result
+type because of overflow, the program is ill-formed.
+The following code shows some duration literals.
+``` cpp
+using namespace std::chrono_literals;
+auto constexpr aday=24h;
+auto constexpr lesson=45min;
+auto constexpr halfanhour=0.5h;
+```
+``` cpp
+constexpr chrono::hours                                 operator "" h(unsigned long long hours);
+constexpr chrono::duration<unspecified, ratio<3600,1>> operator "" h(long double hours);
+```
+*Returns:* A `duration` literal representing `hours` hours.
+``` cpp
+constexpr chrono::minutes                             operator "" min(unsigned long long minutes);
+constexpr chrono::duration<unspecified, ratio<60,1>> operator "" min(long double minutes);
+```
+*Returns:* A `duration` literal representing `minutes` minutes.
+``` cpp
+constexpr chrono::seconds                operator "" s(unsigned long long sec);
+constexpr chrono::duration<unspecified> operator "" s(long double sec);
+```
+*Returns:* A `duration` literal representing `sec` seconds.
+The same suffix `s` is used for `basic_string` but there is no conflict,
+since duration suffixes apply to numbers and string literal suffixes
+apply to character array literals.
+``` cpp
+constexpr chrono::milliseconds                  operator "" ms(unsigned long long msec);
+constexpr chrono::duration<unspecified, milli> operator "" ms(long double msec);
+```
+*Returns:* A `duration` literal representing `msec` milliseconds.
+``` cpp
+constexpr chrono::microseconds                  operator "" us(unsigned long long usec);
+constexpr chrono::duration<unspecified, micro> operator "" us(long double usec);
+```
+*Returns:* A `duration` literal representing `usec` microseconds.
+``` cpp
+constexpr chrono::nanoseconds                  operator "" ns(unsigned long long nsec);
+constexpr chrono::duration<unspecified, nano> operator "" ns(long double nsec);
+```
+*Returns:* A `duration` literal representing `nsec` nanoseconds.

Diff to HTML by rtfpessoa