[dcl.fct.def] - C++14 → C++17

Files changed (1) hide show

tmp/tmppuposiym/{from.md → to.md} +78 -42

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

@@ -21,22 +21,18 @@ Any informal reference to the body of a function should be interpreted
 as a reference to the non-terminal *function-body*. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
 function. A *virt-specifier-seq* can be part of a *function-definition*
 only if it is a *member-declaration* ([[class.mem]]).
-The *declarator* in a *function-definition* shall have the form
-``` bnf
-'D1 (' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-      ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
-```
-as described in  [[dcl.fct]]. A function shall be defined only in
-namespace or class scope.
-a simple example of a complete function definition is
 ``` cpp
 int max(int a, int b, int c) {
   int m = (a > b) ? a : b;
   return (m > c) ? m : c;
@@ -44,26 +40,30 @@ int max(int a, int b, int c) {
 ```
 Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 `c)` is the *declarator*; `{ /* ... */ }` is the *function-body*.
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
-A *cv-qualifier-seq* or a *ref-qualifier* (or both) can be part of a
-non-static member function declaration, non-static member function
-definition, or pointer to member function only ([[dcl.fct]]); see
-[[class.this]].
 Unused parameters need not be named. For example,
 ``` cpp
 void print(int a, int) {
   std::printf("a = %d\n",a);
 }
 ```
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
 (see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
@@ -73,20 +73,24 @@ definition of the form
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
-distinct from that of any other object in the program.[^13]
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
 };
 void f(const char* s = __func__);   // error: __func__ is undeclared
 ```
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
@@ -102,52 +106,58 @@ explicitly defaulted shall
   copy assignment operator, the parameter type may be “reference to
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
-An explicitly-defaulted function may be declared `constexpr` only if it
-would have been implicitly declared as `constexpr`. If a function is
-explicitly defaulted on its first declaration,
-- it is implicitly considered to be `constexpr` if the implicit
-  declaration would be, and,
-- it is implicitly considered to have the same *exception-specification*
-  as if it had been implicitly declared ([[except.spec]]).
-If a function that is explicitly defaulted has an explicit
-*exception-specification* that is not compatible ([[except.spec]]) with
-the *exception-specification* on the implicit declaration, then
 - if the function is explicitly defaulted on its first declaration, it
   is defined as deleted;
 - otherwise, the program is ill-formed.
 ``` cpp
 struct S {
   constexpr S() = default;              // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;               // ill-formed: default argument
   void operator=(const S&) = default;   // ill-formed: non-matching return type
-  ~S() throw(int) = default; // deleted: exception specification does not match
 private:
   int i;
   S(S&);                                // OK: private copy constructor
 };
 S::S(S&) = default;                     // OK: defines copy constructor
 ```
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
 [[class.copy]]), which might mean defining them as deleted. A function
 is *user-provided* if it is user-declared and not explicitly defaulted
 or deleted on its first declaration. A user-provided
 explicitly-defaulted function (i.e., explicitly defaulted after its
 first declaration) is defined at the point where it is explicitly
 defaulted; if such a function is implicitly defined as deleted, the
-program is ill-formed. Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
-enabling a stable binary interface to an evolving code base.
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
@@ -161,10 +171,12 @@ struct nontrivial1 {
   nontrivial1();
 };
 nontrivial1::nontrivial1() = default;   // not first declaration
 ```
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
@@ -173,29 +185,38 @@ attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-spe
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
-other than to declare it, is ill-formed. This includes calling the
-function implicitly or explicitly and forming a pointer or
-pointer-to-member to the function. It applies even for references in
-expressions that are not potentially-evaluated. If a function is
-overloaded, it is referenced only if the function is selected by
-overload resolution.
-One can enforce non-default initialization and non-integral
 initialization with
 ``` cpp
 struct onlydouble {
   onlydouble() = delete;                // OK, but redundant
   onlydouble(std::intmax_t) = delete;
   onlydouble(double);
 };
 ```
-One can prevent use of a class in certain `new` expressions by using
 deleted definitions of a user-declared `operator new` for that class.
 ``` cpp
 struct sometype {
   void* operator new(std::size_t) = delete;
@@ -203,10 +224,14 @@ struct sometype {
 };
 sometype* p = new sometype;     // error, deleted class operator new
 sometype* q = new sometype[3];  // error, deleted class operator new[]
 ```
 One can make a class uncopyable, i.e. move-only, by using deleted
 definitions of the copy constructor and copy assignment operator, and
 then providing defaulted definitions of the move constructor and move
 assignment operator.
@@ -221,18 +246,29 @@ struct moveonly {
 };
 moveonly* p;
 moveonly q(*p);                 // error, deleted copy constructor
 ```
-A deleted function is implicitly inline. The one-definition rule (
-[[basic.def.odr]]) applies to deleted definitions. A deleted definition
-of a function shall be the first declaration of the function or, for an
-explicit specialization of a function template, the first declaration of
-that specialization.
 ``` cpp
 struct sometype {
   sometype();
 };
 sometype::sometype() = delete;  // ill-formed; not first declaration
 ```

 as a reference to the non-terminal *function-body*. The optional
 *attribute-specifier-seq* in a *function-definition* appertains to the
 function. A *virt-specifier-seq* can be part of a *function-definition*
 only if it is a *member-declaration* ([[class.mem]]).
+In a *function-definition*, either `void` *declarator* `;` or
+*declarator* `;` shall be a well-formed function declaration as
+described in  [[dcl.fct]]. A function shall be defined only in namespace
+or class scope.
+[*Example 1*:
+A simple example of a complete function definition is
 ``` cpp
 int max(int a, int b, int c) {
   int m = (a > b) ? a : b;
   return (m > c) ? m : c;
 ```
 Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 `c)` is the *declarator*; `{ /* ... */ }` is the *function-body*.
+— *end example*]
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
+[*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
+of a member function; see  [[dcl.ref]]. — *end note*]
+[*Note 2*:
 Unused parameters need not be named. For example,
 ``` cpp
 void print(int a, int) {
   std::printf("a = %d\n",a);
 }
 ```
+— *end note*]
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
 (see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
+distinct from that of any other object in the program.[^11]
+[*Example 2*:
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
 };
 void f(const char* s = __func__);   // error: __func__ is undeclared
 ```
+— *end example*]
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
   copy assignment operator, the parameter type may be “reference to
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
+An explicitly-defaulted function that is not defined as deleted may be
+declared `constexpr` only if it would have been implicitly declared as
+`constexpr`. If a function is explicitly defaulted on its first
+declaration, it is implicitly considered to be `constexpr` if the
+implicit declaration would be.
+If a function that is explicitly defaulted is declared with a
+*noexcept-specifier* that does not produce the same exception
+specification as the implicit declaration ([[except.spec]]), then
 - if the function is explicitly defaulted on its first declaration, it
   is defined as deleted;
 - otherwise, the program is ill-formed.
+[*Example 1*:
 ``` cpp
 struct S {
   constexpr S() = default;              // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;               // ill-formed: default argument
   void operator=(const S&) = default;   // ill-formed: non-matching return type
+  ~S() noexcept(false) = default; // deleted: exception specification does not match
 private:
   int i;
   S(S&);                                // OK: private copy constructor
 };
 S::S(S&) = default;                     // OK: defines copy constructor
 ```
+— *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
 [[class.copy]]), which might mean defining them as deleted. A function
 is *user-provided* if it is user-declared and not explicitly defaulted
 or deleted on its first declaration. A user-provided
 explicitly-defaulted function (i.e., explicitly defaulted after its
 first declaration) is defined at the point where it is explicitly
 defaulted; if such a function is implicitly defined as deleted, the
+program is ill-formed.
+[*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
+enabling a stable binary interface to an evolving code
+base. — *end note*]
+[*Example 2*:
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
   nontrivial1();
 };
 nontrivial1::nontrivial1() = default;   // not first declaration
 ```
+— *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
+other than to declare it, is ill-formed.
+[*Note 1*: This includes calling the function implicitly or explicitly
+and forming a pointer or pointer-to-member to the function. It applies
+even for references in expressions that are not potentially-evaluated.
+If a function is overloaded, it is referenced only if the function is
+selected by overload resolution. The implicit odr-use (
+[[basic.def.odr]]) of a virtual function does not, by itself, constitute
+a reference. — *end note*]
+[*Example 1*:
+One can enforce non-default-initialization and non-integral
 initialization with
 ``` cpp
 struct onlydouble {
   onlydouble() = delete;                // OK, but redundant
   onlydouble(std::intmax_t) = delete;
   onlydouble(double);
 };
 ```
+— *end example*]
+[*Example 2*:
+One can prevent use of a class in certain *new-expression*s by using
 deleted definitions of a user-declared `operator new` for that class.
 ``` cpp
 struct sometype {
   void* operator new(std::size_t) = delete;
 };
 sometype* p = new sometype;     // error, deleted class operator new
 sometype* q = new sometype[3];  // error, deleted class operator new[]
 ```
+— *end example*]
+[*Example 3*:
 One can make a class uncopyable, i.e. move-only, by using deleted
 definitions of the copy constructor and copy assignment operator, and
 then providing defaulted definitions of the move constructor and move
 assignment operator.
 };
 moveonly* p;
 moveonly q(*p);                 // error, deleted copy constructor
 ```
+— *end example*]
+A deleted function is implicitly an inline function ([[dcl.inline]]).
+[*Note 2*: The one-definition rule ([[basic.def.odr]]) applies to
+deleted definitions. — *end note*]
+A deleted definition of a function shall be the first declaration of the
+function or, for an explicit specialization of a function template, the
+first declaration of that specialization. An implicitly declared
+allocation or deallocation function ([[basic.stc.dynamic]]) shall not
+be defined as deleted.
+[*Example 4*:
 ``` cpp
 struct sometype {
   sometype();
 };
 sometype::sometype() = delete;  // ill-formed; not first declaration
 ```
+— *end example*]

Diff to HTML by rtfpessoa