[thread.thread.class] - C++17 → C++20

Files changed (1) hide show

tmp/tmpy9hakkos/{from.md → to.md} +70 -94

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

@@ -17,33 +17,33 @@ successful call to `detach` or `join`. — *end note*]
 ``` cpp
 namespace std {
   class thread {
   public:
-    // types:
     class id;
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    // construct/copy/destroy:
     thread() noexcept;
     template<class F, class... Args> explicit thread(F&& f, Args&&... args);
     ~thread();
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
-    // members:
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
-    native_handle_type native_handle(); // See~[thread.req.native]
-    // static members:
-    static unsigned hardware_concurrency() noexcept;
   };
 }
 ```
 #### Class `thread::id` <a id="thread.thread.id">[[thread.thread.id]]</a>
@@ -54,150 +54,129 @@ namespace std {
   public:
     id() noexcept;
   };
   bool operator==(thread::id x, thread::id y) noexcept;
- bool operator!=(thread::id x, thread::id y) noexcept;
-  bool operator<(thread::id x, thread::id y) noexcept;
-  bool operator<=(thread::id x, thread::id y) noexcept;
-  bool operator>(thread::id x, thread::id y) noexcept;
-  bool operator>=(thread::id x, thread::id y) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
-  // Hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 An object of type `thread::id` provides a unique identifier for each
 thread of execution and a single distinct value for all `thread` objects
-that do not represent a thread of execution ([[thread.thread.class]]).
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
-`thread::id` shall be a trivially copyable class (Clause  [[class]]).
-The library may reuse the value of a `thread::id` of a terminated thread
-that can no longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 as keys in associative containers. — *end note*]
 ``` cpp
 id() noexcept;
 ```
-*Effects:* Constructs an object of type `id`.
-*Postconditions:* The constructed object does not represent a thread of
 execution.
 ``` cpp
 bool operator==(thread::id x, thread::id y) noexcept;
 ```
 *Returns:* `true` only if `x` and `y` represent the same thread of
 execution or neither `x` nor `y` represents a thread of execution.
 ``` cpp
-bool operator!=(thread::id x, thread::id y) noexcept;
 ```
-*Returns:* `!(x == y)`
-``` cpp
-bool operator<(thread::id x, thread::id y) noexcept;
-```
-*Returns:* A value such that `operator<` is a total ordering as
-described in  [[alg.sorting]].
-``` cpp
-bool operator<=(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `!(y < x)`.
-``` cpp
-bool operator>(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `y < x`.
-``` cpp
-bool operator>=(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `!(x < y)`.
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
 *Effects:* Inserts an unspecified text representation of `id` into
 `out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
-`thread::id` objects shall have the same text representation and if
-`x != y` the `thread::id` objects shall have distinct text
-representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
-The specialization is enabled ([[unord.hash]]).
-#### `thread` constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
 ```
-*Effects:* Constructs a `thread` object that does not represent a thread
-of execution.
-*Postconditions:* `get_id() == id()`.
 ``` cpp
 template<class F, class... Args> explicit thread(F&& f, Args&&... args);
 ```
-*Requires:*  `F` and each `Ti` in `Args` shall satisfy the
-`MoveConstructible` requirements.
-` `*`INVOKE`*`( `*`DECAY_COPY`*`( std::forward<F>(f)), `*`DECAY_COPY`*`( std::forward<Args>(args))...)` ([[func.require]])
-shall be a valid expression.
-*Remarks:* This constructor shall not participate in overload resolution
-if `decay_t<F>` is the same type as `std::thread`.
-*Effects:*  Constructs an object of type `thread`. The new thread of
-execution executes
-` `*`INVOKE`*`( `*`DECAY_COPY`*`( std::forward<F>(f)), `*`DECAY_COPY`*`( std::forward<Args>(args))...)`
-with the calls to *`DECAY_COPY`* being evaluated in the constructing
 thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
-If the invocation of
-` `*`INVOKE`*`( `*`DECAY_COPY`*`( std::forward<F>(f)), `*`DECAY_COPY`*`( std::forward<Args>(args))...)`
-terminates with an uncaught exception, `terminate` shall be called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
-*Postconditions:* `get_id() != id()`. `*this` represents the newly
-started thread.
 *Throws:* `system_error` if unable to start the new thread.
 *Error conditions:*
@@ -207,45 +186,43 @@ started thread.
 ``` cpp
 thread(thread&& x) noexcept;
 ```
-*Effects:* Constructs an object of type `thread` from `x`, and sets `x`
-to a default constructed state.
-*Postconditions:* `x.get_id() == id()` and `get_id()` returns the value
-of `x.get_id()` prior to the start of construction.
-#### `thread` destructor <a id="thread.thread.destr">[[thread.thread.destr]]</a>
 ``` cpp
 ~thread();
 ```
-If `joinable()`, calls `terminate()`. Otherwise, has no effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
 in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
 exception is thrown. Thus the programmer must ensure that the destructor
 is never executed while the thread is still joinable. — *end note*]
-#### `thread` assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
 *Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
 state of `x` to `*this` and sets `x` to a default constructed state.
-*Postconditions:* `x.get_id() == id()` and `get_id()` returns the value
-of `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
-#### `thread` members <a id="thread.thread.member">[[thread.thread.member]]</a>
 ``` cpp
 void swap(thread& x) noexcept;
 ```
@@ -259,24 +236,23 @@ bool joinable() const noexcept;
 ``` cpp
 void join();
 ```
-*Effects:*  Blocks until the thread represented by `*this` has
-completed.
 *Synchronization:* The completion of the thread represented by `*this`
-synchronizes with ([[intro.multithread]]) the corresponding successful
 `join()` return.
 [*Note 1*: Operations on `*this` are not synchronized. — *end note*]
-*Postconditions:* The thread represented by `*this` has completed.
 `get_id() == id()`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `resource_deadlock_would_occur` — if deadlock is detected or
   `get_id() == this_thread::get_id()`.
@@ -289,16 +265,16 @@ void detach();
 *Effects:* The thread represented by `*this` continues execution without
 the calling thread blocking. When `detach()` returns, `*this` no longer
 represents the possibly continuing thread of execution. When the thread
 previously represented by `*this` ends execution, the implementation
-shall release any owned resources.
-*Postconditions:* `get_id() == id()`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
@@ -309,25 +285,25 @@ id get_id() const noexcept;
 *Returns:* A default constructed `id` object if `*this` does not
 represent a thread, otherwise `this_thread::get_id()` for the thread of
 execution represented by `*this`.
-#### `thread` static members <a id="thread.thread.static">[[thread.thread.static]]</a>
 ``` cpp
 unsigned hardware_concurrency() noexcept;
 ```
 *Returns:* The number of hardware thread contexts.
 [*Note 1*: This value should only be considered to be a
 hint. — *end note*]
-If this value is not computable or well defined an implementation should
-return 0.
-#### `thread` specialized algorithms <a id="thread.thread.algorithm">[[thread.thread.algorithm]]</a>
 ``` cpp
 void swap(thread& x, thread& y) noexcept;
 ```

 ``` cpp
 namespace std {
   class thread {
   public:
+    // types
     class id;
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    // construct/copy/destroy
     thread() noexcept;
     template<class F, class... Args> explicit thread(F&& f, Args&&... args);
     ~thread();
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
+    // members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
+    native_handle_type native_handle(); // see~[thread.req.native]
+    // static members
+    static unsigned int hardware_concurrency() noexcept;
   };
 }
 ```
 #### Class `thread::id` <a id="thread.thread.id">[[thread.thread.id]]</a>
   public:
     id() noexcept;
   };
   bool operator==(thread::id x, thread::id y) noexcept;
+ strong_ordering operator<=>(thread::id x, thread::id y) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
+  // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 An object of type `thread::id` provides a unique identifier for each
 thread of execution and a single distinct value for all `thread` objects
+that do not represent a thread of execution [[thread.thread.class]].
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
+`thread::id` is a trivially copyable class [[class.prop]]. The library
+may reuse the value of a `thread::id` of a terminated thread that can no
+longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 as keys in associative containers. — *end note*]
 ``` cpp
 id() noexcept;
 ```
+*Ensures:* The constructed object does not represent a thread of
 execution.
 ``` cpp
 bool operator==(thread::id x, thread::id y) noexcept;
 ```
 *Returns:* `true` only if `x` and `y` represent the same thread of
 execution or neither `x` nor `y` represents a thread of execution.
 ``` cpp
+strong_ordering operator<=>(thread::id x, thread::id y) noexcept;
 ```
+Let P(`x`, `y`) be an unspecified total ordering over `thread::id` as
+described in [[alg.sorting]].
+*Returns:* `strong_ordering::less` if P(`x`, `y`) is `true`. Otherwise,
+`strong_ordering::greater` if P(`y`, `x`) is `true`. Otherwise,
+`strong_ordering::equal`.
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
 *Effects:* Inserts an unspecified text representation of `id` into
 `out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
+`thread::id` objects have the same text representation and if `x != y`
+the `thread::id` objects have distinct text representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
+The specialization is enabled [[unord.hash]].
+#### Constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
 ```
+*Effects:* The object does not represent a thread of execution.
+*Ensures:* `get_id() == id()`.
 ``` cpp
 template<class F, class... Args> explicit thread(F&& f, Args&&... args);
 ```
+*Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
+*Mandates:* The following are all `true`:
+- `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
+- `is_move_constructible_v<decay_t<F>>`,
+- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
+- `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
+*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
+*Cpp17MoveConstructible* requirements.
+*Effects:* The new thread of execution executes
+``` cpp
+invoke(decay-copy(std::forward<F>(f)), decay-copy(std::forward<Args>(args))...)
+```
+with the calls to *`decay-copy`* being evaluated in the constructing
 thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
+If the invocation of `invoke` terminates with an uncaught exception,
+`terminate` is called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
+*Ensures:* `get_id() != id()`. `*this` represents the newly started
+thread.
 *Throws:* `system_error` if unable to start the new thread.
 *Error conditions:*
 ``` cpp
 thread(thread&& x) noexcept;
 ```
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the start of construction.
+#### Destructor <a id="thread.thread.destr">[[thread.thread.destr]]</a>
 ``` cpp
 ~thread();
 ```
+*Effects:* If `joinable()`, calls `terminate()`. Otherwise, has no
+effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
 in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
 exception is thrown. Thus the programmer must ensure that the destructor
 is never executed while the thread is still joinable. — *end note*]
+#### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
 *Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
 state of `x` to `*this` and sets `x` to a default constructed state.
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the assignment.
 *Returns:* `*this`.
+#### Members <a id="thread.thread.member">[[thread.thread.member]]</a>
 ``` cpp
 void swap(thread& x) noexcept;
 ```
 ``` cpp
 void join();
 ```
+*Effects:* Blocks until the thread represented by `*this` has completed.
 *Synchronization:* The completion of the thread represented by `*this`
+synchronizes with [[intro.multithread]] the corresponding successful
 `join()` return.
 [*Note 1*: Operations on `*this` are not synchronized. — *end note*]
+*Ensures:* The thread represented by `*this` has completed.
 `get_id() == id()`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `resource_deadlock_would_occur` — if deadlock is detected or
   `get_id() == this_thread::get_id()`.
 *Effects:* The thread represented by `*this` continues execution without
 the calling thread blocking. When `detach()` returns, `*this` no longer
 represents the possibly continuing thread of execution. When the thread
 previously represented by `*this` ends execution, the implementation
+releases any owned resources.
+*Ensures:* `get_id() == id()`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
 *Returns:* A default constructed `id` object if `*this` does not
 represent a thread, otherwise `this_thread::get_id()` for the thread of
 execution represented by `*this`.
+#### Static members <a id="thread.thread.static">[[thread.thread.static]]</a>
 ``` cpp
 unsigned hardware_concurrency() noexcept;
 ```
 *Returns:* The number of hardware thread contexts.
 [*Note 1*: This value should only be considered to be a
 hint. — *end note*]
+If this value is not computable or well-defined, an implementation
+should return 0.
+#### Specialized algorithms <a id="thread.thread.algorithm">[[thread.thread.algorithm]]</a>
 ``` cpp
 void swap(thread& x, thread& y) noexcept;
 ```

Diff to HTML by rtfpessoa