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

Files changed (1) hide show

tmp/tmp5pzvgn83/{from.md → to.md} +52 -45

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

@@ -7,21 +7,23 @@ thread. A `thread` object uniquely represents a particular thread of
 execution. That representation may be transferred to other `thread`
 objects in such a way that no two `thread` objects simultaneously
 represent the same thread of execution. A thread of execution is
 *detached* when no `thread` object represents that thread. Objects of
 class `thread` can be in a state that does not represent a thread of
-execution. A `thread` object does not represent a thread of execution
 after default construction, after being moved from, or after a
-successful call to `detach` or `join`.
 ``` cpp
 namespace std {
   class thread {
   public:
     // types:
     class id;
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     // construct/copy/destroy:
     thread() noexcept;
     template <class F, class... Args> explicit thread(F&& f, Args&&... args);
     ~thread();
@@ -73,19 +75,19 @@ namespace std {
 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 `std::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.
-Relational operators allow `thread::id` objects to be used as keys in
-associative containers.
 ``` cpp
 id() noexcept;
 ```
@@ -116,78 +118,80 @@ 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 template specialization shall meet the requirements of class
-template `hash` ([[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.
-`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. 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. If the
-invocation of *`INVOKE`*`(`*`DECAY_COPY`*`(`
-`std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
-terminates with an uncaught exception, `std::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
@@ -215,30 +219,31 @@ of `x.get_id()` prior to the start of construction.
 ``` cpp
 ~thread();
 ```
-If `joinable()`, calls `std::terminate()`. Otherwise, has no effects.
-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
-raised. Thus the programmer must ensure that the destructor is never
-executed while the thread is still joinable.
 #### `thread` assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
-*Effects:* If `joinable()`, calls `std::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;
@@ -248,51 +253,49 @@ void swap(thread& x) noexcept;
 ``` cpp
 bool joinable() const noexcept;
 ```
-*Returns:* `get_id() != id()`
 ``` cpp
 void join();
 ```
-`joinable()` is `true`.
 *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. Operations on `*this` are not synchronized.
 *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
-  `this->get_id() == std::this_thread::get_id()`.
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
 ``` cpp
 void detach();
 ```
-`joinable()` is `true`.
 *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.
-`get_id() == id()`.
 *Throws:* `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
@@ -312,17 +315,21 @@ execution represented by `*this`.
 ``` cpp
 unsigned hardware_concurrency() noexcept;
 ```
-*Returns:* The number of hardware thread contexts. This value should
-only be considered to be a hint. 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;
 ```
-*Effects:* `x.swap(y)`

 execution. That representation may be transferred to other `thread`
 objects in such a way that no two `thread` objects simultaneously
 represent the same thread of execution. A thread of execution is
 *detached* when no `thread` object represents that thread. Objects of
 class `thread` can be in a state that does not represent a thread of
+execution.
+[*Note 1*: A `thread` object does not represent a thread of execution
 after default construction, after being moved from, or after a
+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();
 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;
 ```
 ``` 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
 ``` 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;
 ``` cpp
 bool joinable() const noexcept;
 ```
+*Returns:* `get_id() != id()`.
 ``` 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()`.
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
 ``` cpp
 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:*
 ``` 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;
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa