[func.wrap.func] - C++11 → C++14

Files changed (1) hide show

tmp/tmpqjydqm1o/{from.md → to.md} +23 -17

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

@@ -6,15 +6,15 @@ namespace std {
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     typedef R result_type;
-    typedef T1 argument_type;           // iff sizeof...(ArgTypes) == 1 and
                                         // the type in ArgTypes is T1
-    typedef T1 first_argument_type;     // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
-    typedef T2 second_argument_type;    // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
     // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
@@ -48,12 +48,12 @@ namespace std {
     // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
     // [func.wrap.func.targ], function target access:
     const std::type_info& target_type() const noexcept;
-    template <typename T>       T* target() noexcept;
-    template <typename T> const T* target() const noexcept;
   };
   // [func.wrap.func.nullptr], Null pointer comparisons:
   template <class R, class... ArgTypes>
@@ -142,20 +142,21 @@ state with an unspecified value.
 ``` cpp
 template<class F> function(F f);
 template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
-*Requires:* `F` shall be `CopyConstructible`. `f` shall be
-Callable ([[func.wrap.func]]) for argument types `ArgTypes` and return
-type `R`. The copy constructor and destructor of `A` shall not throw
-exceptions.
 *Postconditions:* `!*this` if any of the following hold:
-- `f` is a NULL function pointer.
-- `f` is a NULL pointer to member.
-- `F` is an instance of the `function` class template, and `!f`
 Otherwise, `*this` targets a copy of `f` initialized with
 `std::move(f)`. Implementations are encouraged to avoid the use of
 dynamically allocated memory for small callable objects, for example,
 where `f`’s target is an object holding only a pointer or reference to
@@ -183,11 +184,11 @@ function& operator=(function&& f);
 ``` cpp
 function& operator=(nullptr_t);
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
@@ -197,10 +198,15 @@ template<class F> function& operator=(F&& f);
 *Effects:* `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* `function(f).swap(*this);`
@@ -209,11 +215,11 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ``` cpp
 ~function();
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
@@ -260,18 +266,18 @@ const std::type_info& target_type() const noexcept;
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
-template<typename T>       T* target() noexcept;
-template<typename T> const T* target() const noexcept;
 ```
 *Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
 for parameter types `ArgTypes` and return type `R`.
-*Returns:* If `target_`type() == typeid(T) a pointer to the stored
 function target; otherwise a null pointer.
 ##### null pointer comparison operators <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp

   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     typedef R result_type;
+    typedef T1 argument_type;           // only if sizeof...(ArgTypes) == 1 and
                                         // the type in ArgTypes is T1
+    typedef T1 first_argument_type;     // only if sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
+    typedef T2 second_argument_type;    // only if sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
     // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
     // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
     // [func.wrap.func.targ], function target access:
     const std::type_info& target_type() const noexcept;
+    template<class T>       T* target() noexcept;
+    template<class T> const T* target() const noexcept;
   };
   // [func.wrap.func.nullptr], Null pointer comparisons:
   template <class R, class... ArgTypes>
 ``` cpp
 template<class F> function(F f);
 template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
+*Requires:* `F` shall be `CopyConstructible`.
+*Remarks:* These constructors shall not participate in overload
+resolution unless `f` is Callable ([[func.wrap.func]]) for argument
+types `ArgTypes...` and return type `R`.
 *Postconditions:* `!*this` if any of the following hold:
+- `f` is a null function pointer value.
+- `f` is a null member pointer value.
+- `F` is an instance of the `function` class template, and `!f`.
 Otherwise, `*this` targets a copy of `f` initialized with
 `std::move(f)`. Implementations are encouraged to avoid the use of
 dynamically allocated memory for small callable objects, for example,
 where `f`’s target is an object holding only a pointer or reference to
 ``` cpp
 function& operator=(nullptr_t);
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
 *Effects:* `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`
+*Remarks:* This assignment operator shall not participate in overload
+resolution unless `declval<typename decay<F>::type&>()` is
+Callable ([[func.wrap.func]]) for argument types `ArgTypes...` and
+return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* `function(f).swap(*this);`
 ``` cpp
 ~function();
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
+template<class T>       T* target() noexcept;
+template<class T> const T* target() const noexcept;
 ```
 *Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
 for parameter types `ArgTypes` and return type `R`.
+*Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
 ##### null pointer comparison operators <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp

Diff to HTML by rtfpessoa