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

Files changed (1) hide show

tmp/tmp2nr_t1c1/{from.md → to.md} +26 -25

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

@@ -62,22 +62,22 @@ void print(int a, int) {
 }
 ```
 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.local]]).
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
 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.[^14]
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
@@ -88,11 +88,11 @@ 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
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator ' = default ;'
 ```
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
@@ -103,50 +103,51 @@ explicitly defaulted shall
   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`, and may have an
-explicit *exception-specification* only if it is compatible (
-[[except.spec]]) with the *exception-specification* on the implicit
-declaration. If a function is explicitly defaulted on its first
-declaration,
 - it is implicitly considered to be `constexpr` if the implicit
-  declaration would be,
 - it is implicitly considered to have the same *exception-specification*
-  as if it had been implicitly declared ([[except.spec]]), and
-- in the case of a copy constructor, move constructor, copy assignment
-  operator, or move assignment operator, it shall have the same
-  parameter type as if it had been implicitly declared.
 ``` 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;                // ill-formed: 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 special
-member 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;
@@ -165,11 +166,11 @@ 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
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator ' = delete ;'
 ```
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.

 }
 ```
 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
 definition of the form
 ``` cpp
 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;
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = default ;'
 ```
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
   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;
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = delete ;'
 ```
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.

Diff to HTML by rtfpessoa