[basic.def.odr] - C++14 → C++17

Files changed (1) hide show

tmp/tmpx1tyugmc/{from.md → to.md} +105 -64

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

@@ -1,16 +1,18 @@
-## One definition rule <a id="basic.def.odr">[[basic.def.odr]]</a>
 No translation unit shall contain more than one definition of any
 variable, function, class type, enumeration type, or template.
 An expression is *potentially evaluated* unless it is an unevaluated
 operand (Clause  [[expr]]) or a subexpression thereof. The set of
 *potential results* of an expression `e` is defined as follows:
-- If `e` is an *id-expression* ([[expr.prim.general]]), the set
- contains only `e`.
 - If `e` is a class member access expression ([[expr.ref]]), the set
   contains the potential results of the object expression.
 - If `e` is a pointer-to-member expression ([[expr.mptr.oper]]) whose
   second operand is a constant expression, the set contains the
   potential results of the object expression.
@@ -21,23 +23,32 @@ operand (Clause  [[expr]]) or a subexpression thereof. The set of
   operands.
 - If `e` is a comma expression ([[expr.comma]]), the set contains the
   potential results of the right operand.
 - Otherwise, the set is empty.
 This set is a (possibly-empty) set of *id-expression*s, each of which is
-either `e` or a subexpression of `e`. In the following example, the set
-of potential results of the initializer of `n` contains the first `S::x`
-subexpression, but not the second `S::x` subexpression.
 ``` cpp
 struct S { static const int x = 0; };
 const int &f(const int &r);
 int n = b ? (1, S::x)  // S::x is not odr-used here
-          : f(S::x);   // S::x is odr-used here, so
-                       // a definition is required
 ```
 A variable `x` whose name appears as a potentially-evaluated expression
 `ex` is *odr-used* by `ex` unless applying the lvalue-to-rvalue
 conversion ([[conv.lval]]) to `x` yields a constant expression (
 [[expr.const]]) that does not invoke any non-trivial functions and, if
 `x` is an object, `ex` is an element of the set of potential results of
@@ -49,70 +60,82 @@ implicit transformation in the body of a non-static member function (
 [[class.mfct.non-static]])). A virtual member function is odr-used if it
 is not pure. A function whose name appears as a potentially-evaluated
 expression is odr-used if it is the unique lookup result or the selected
 member of a set of overloaded functions ([[basic.lookup]],
 [[over.match]], [[over.over]]), unless it is a pure virtual function and
-its name is not explicitly qualified. This covers calls to named
-functions ([[expr.call]]), operator overloading (Clause  [[over]]),
-user-defined conversions ([[class.conv.fct]]), allocation function for
-placement new ([[expr.new]]), as well as non-default initialization (
-[[dcl.init]]). A constructor selected to copy or move an object of class
-type is odr-used even if the call is actually elided by the
-implementation ([[class.copy]]). An allocation or deallocation function
-for a class is odr-used by a new expression appearing in a
-potentially-evaluated expression as specified in  [[expr.new]] and
-[[class.free]]. A deallocation function for a class is odr-used by a
-delete expression appearing in a potentially-evaluated expression as
-specified in  [[expr.delete]] and  [[class.free]]. A non-placement
-allocation or deallocation function for a class is odr-used by the
-definition of a constructor of that class. A non-placement deallocation
-function for a class is odr-used by the definition of the destructor of
-that class, or by being selected by the lookup at the point of
-definition of a virtual destructor ([[class.dtor]]).[^2] An assignment
-operator function in a class is odr-used by an implicitly-defined
-copy-assignment or move-assignment function for another class as
-specified in  [[class.copy]]. A default constructor for a class is
-odr-used by default initialization or value initialization as specified
-in  [[dcl.init]]. A constructor for a class is odr-used as specified in
-[[dcl.init]]. A destructor for a class is odr-used if it is potentially
-invoked ([[class.dtor]]).
 Every program shall contain exactly one definition of every non-inline
-function or variable that is odr-used in that program; no diagnostic
-required. The definition can appear explicitly in the program, it can be
-found in the standard or a user-defined library, or (when appropriate)
-it is implicitly defined (see  [[class.ctor]], [[class.dtor]] and
-[[class.copy]]). An inline function shall be defined in every
-translation unit in which it is odr-used.
 Exactly one definition of a class is required in a translation unit if
 the class is used in a way that requires the class type to be complete.
-the following complete translation unit is well-formed, even though it
 never defines `X`:
 ``` cpp
 struct X;                       // declare X as a struct type
 struct X* x1;                   // use X in pointer formation
 X* x2;                          // use X in pointer formation
 ```
 The rules for declarations and expressions describe in which contexts
 complete class types are required. A class type `T` must be complete if:
 - an object of type `T` is defined ([[basic.def]]), or
 - a non-static class data member of type `T` is declared (
   [[class.mem]]), or
-- `T` is used as the object type or array element type in a
   *new-expression* ([[expr.new]]), or
 - an lvalue-to-rvalue conversion is applied to a glvalue referring to an
   object of type `T` ([[conv.lval]]), or
 - an expression is converted (either implicitly or explicitly) to type
   `T` (Clause  [[conv]], [[expr.type.conv]], [[expr.dynamic.cast]],
   [[expr.static.cast]], [[expr.cast]]), or
 - an expression that is not a null pointer constant, and has type other
-  than *cv* `void*`, is converted to the type pointer to `T` or
- reference to `T` using a standard conversion (Clause  [[conv]]), a
   `dynamic_cast` ([[expr.dynamic.cast]]) or a `static_cast` (
   [[expr.static.cast]]), or
 - a class member access operator is applied to an expression of type
   `T` ([[expr.ref]]), or
 - the `typeid` operator ([[expr.typeid]]) or the `sizeof` operator (
@@ -125,15 +148,18 @@ complete class types are required. A class type `T` must be complete if:
 - the type `T` is the subject of an `alignof` expression (
   [[expr.alignof]]), or
 - an *exception-declaration* has type `T`, reference to `T`, or pointer
   to `T` ([[except.handle]]).
 There can be more than one definition of a class type (Clause
 [[class]]), enumeration type ([[dcl.enum]]), inline function with
-external linkage ([[dcl.fct.spec]]), class template (Clause  [[temp]]),
-non-static function template ([[temp.fct]]), static data member of a
-class template ([[temp.static]]), member function of a class template (
 [[temp.mem.func]]), or template specialization for which some template
 parameters are not specified ([[temp.spec]], [[temp.class.spec]]) in a
 program provided that each definition appears in a different translation
 unit, and provided the definitions satisfy the following requirements.
 Given such an entity named `D` defined in more than one translation
@@ -143,54 +169,69 @@ unit, then
   and
 - in each definition of `D`, corresponding names, looked up according
   to  [[basic.lookup]], shall refer to an entity defined within the
   definition of `D`, or shall refer to the same entity, after overload
   resolution ([[over.match]]) and after matching of partial template
-  specialization ([[temp.over]]), except that a name can refer to a
-  non-volatile `const` object with internal or no linkage if the object
-  has the same literal type in all definitions of `D`, and the object is
-  initialized with a constant expression ([[expr.const]]), and the
-  object is not odr-used, and the object has the same value in all
-  definitions of `D`; and
 - in each definition of `D`, corresponding entities shall have the same
   language linkage; and
 - in each definition of `D`, the overloaded operators referred to, the
   implicit calls to conversion functions, constructors, operator new
   functions and operator delete functions, shall refer to the same
   function, or to a function defined within the definition of `D`; and
 - in each definition of `D`, a default argument used by an (implicit or
   explicit) function call is treated as if its token sequence were
   present in the definition of `D`; that is, the default argument is
-  subject to the three requirements described above (and, if the default
-  argument has sub-expressions with default arguments, this requirement
-  applies recursively).[^3]
 - if `D` is a class with an implicitly-declared constructor (
   [[class.ctor]]), it is as if the constructor was implicitly defined in
   every translation unit where it is odr-used, and the implicit
   definition in every translation unit shall call the same constructor
-  for a base class or a class member of `D`.
   ``` cpp
   // translation unit 1:
   struct X {
-    X(int);
     X(int, int);
   };
-  X::X(int = 0) { }
-  class D: public X { };
-  D d2;                           // X(int) called by D()
   // translation unit 2:
   struct X {
-    X(int);
     X(int, int);
   };
-  X::X(int = 0, int = 0) { }
-  class D: public X { };          // X(int, int) called by D();
-                                  // D()'s implicit definition
-                                  // violates the ODR
   ```
 If `D` is a template and is defined in more than one translation unit,
 then the preceding requirements shall apply both to names from the
 template’s enclosing scope used in the template definition (
 [[temp.nondep]]), and also to dependent names at the point of
 instantiation ([[temp.dep]]). If the definitions of `D` satisfy all

+## One-definition rule <a id="basic.def.odr">[[basic.def.odr]]</a>
 No translation unit shall contain more than one definition of any
 variable, function, class type, enumeration type, or template.
 An expression is *potentially evaluated* unless it is an unevaluated
 operand (Clause  [[expr]]) or a subexpression thereof. The set of
 *potential results* of an expression `e` is defined as follows:
+- If `e` is an *id-expression* ([[expr.prim.id]]), the set contains
+  only `e`.
+- If `e` is a subscripting operation ([[expr.sub]]) with an array
+  operand, the set contains the potential results of that operand.
 - If `e` is a class member access expression ([[expr.ref]]), the set
   contains the potential results of the object expression.
 - If `e` is a pointer-to-member expression ([[expr.mptr.oper]]) whose
   second operand is a constant expression, the set contains the
   potential results of the object expression.
   operands.
 - If `e` is a comma expression ([[expr.comma]]), the set contains the
   potential results of the right operand.
 - Otherwise, the set is empty.
+[*Note 1*:
 This set is a (possibly-empty) set of *id-expression*s, each of which is
+either `e` or a subexpression of `e`.
+[*Example 1*:
+In the following example, the set of potential results of the
+initializer of `n` contains the first `S::x` subexpression, but not the
+second `S::x` subexpression.
 ``` cpp
 struct S { static const int x = 0; };
 const int &f(const int &r);
 int n = b ? (1, S::x)  // S::x is not odr-used here
+          : f(S::x);   // S::x is odr-used here, so a definition is required
 ```
+— *end example*]
+— *end note*]
 A variable `x` whose name appears as a potentially-evaluated expression
 `ex` is *odr-used* by `ex` unless applying the lvalue-to-rvalue
 conversion ([[conv.lval]]) to `x` yields a constant expression (
 [[expr.const]]) that does not invoke any non-trivial functions and, if
 `x` is an object, `ex` is an element of the set of potential results of
 [[class.mfct.non-static]])). A virtual member function is odr-used if it
 is not pure. A function whose name appears as a potentially-evaluated
 expression is odr-used if it is the unique lookup result or the selected
 member of a set of overloaded functions ([[basic.lookup]],
 [[over.match]], [[over.over]]), unless it is a pure virtual function and
+either its name is not explicitly qualified or the expression forms a
+pointer to member ([[expr.unary.op]]).
+[*Note 2*: This covers calls to named functions ([[expr.call]]),
+operator overloading (Clause  [[over]]), user-defined conversions (
+[[class.conv.fct]]), allocation functions for placement
+*new-expression*s ([[expr.new]]), as well as non-default
+initialization ([[dcl.init]]). A constructor selected to copy or move
+an object of class type is odr-used even if the call is actually elided
+by the implementation ([[class.copy]]). — *end note*]
+An allocation or deallocation function for a class is odr-used by a
+*new-expression* appearing in a potentially-evaluated expression as
+specified in  [[expr.new]] and  [[class.free]]. A deallocation function
+for a class is odr-used by a delete expression appearing in a
+potentially-evaluated expression as specified in  [[expr.delete]] and
+[[class.free]]. A non-placement allocation or deallocation function for
+a class is odr-used by the definition of a constructor of that class. A
+non-placement deallocation function for a class is odr-used by the
+definition of the destructor of that class, or by being selected by the
+lookup at the point of definition of a virtual destructor (
+[[class.dtor]]).[^2] An assignment operator function in a class is
+odr-used by an implicitly-defined copy-assignment or move-assignment
+function for another class as specified in  [[class.copy]]. A
+constructor for a class is odr-used as specified in  [[dcl.init]]. A
+destructor for a class is odr-used if it is potentially invoked (
+[[class.dtor]]).
 Every program shall contain exactly one definition of every non-inline
+function or variable that is odr-used in that program outside of a
+discarded statement ([[stmt.if]]); no diagnostic required. The
+definition can appear explicitly in the program, it can be found in the
+standard or a user-defined library, or (when appropriate) it is
+implicitly defined (see  [[class.ctor]], [[class.dtor]] and
+[[class.copy]]). An inline function or variable shall be defined in
+every translation unit in which it is odr-used outside of a discarded
+statement.
 Exactly one definition of a class is required in a translation unit if
 the class is used in a way that requires the class type to be complete.
+[*Example 2*:
+The following complete translation unit is well-formed, even though it
 never defines `X`:
 ``` cpp
 struct X;                       // declare X as a struct type
 struct X* x1;                   // use X in pointer formation
 X* x2;                          // use X in pointer formation
 ```
+— *end example*]
+[*Note 3*:
 The rules for declarations and expressions describe in which contexts
 complete class types are required. A class type `T` must be complete if:
 - an object of type `T` is defined ([[basic.def]]), or
 - a non-static class data member of type `T` is declared (
   [[class.mem]]), or
+- `T` is used as the allocated type or array element type in a
   *new-expression* ([[expr.new]]), or
 - an lvalue-to-rvalue conversion is applied to a glvalue referring to an
   object of type `T` ([[conv.lval]]), or
 - an expression is converted (either implicitly or explicitly) to type
   `T` (Clause  [[conv]], [[expr.type.conv]], [[expr.dynamic.cast]],
   [[expr.static.cast]], [[expr.cast]]), or
 - an expression that is not a null pointer constant, and has type other
+  than cv `void*`, is converted to the type pointer to `T` or reference
+  to `T` using a standard conversion (Clause  [[conv]]), a
   `dynamic_cast` ([[expr.dynamic.cast]]) or a `static_cast` (
   [[expr.static.cast]]), or
 - a class member access operator is applied to an expression of type
   `T` ([[expr.ref]]), or
 - the `typeid` operator ([[expr.typeid]]) or the `sizeof` operator (
 - the type `T` is the subject of an `alignof` expression (
   [[expr.alignof]]), or
 - an *exception-declaration* has type `T`, reference to `T`, or pointer
   to `T` ([[except.handle]]).
+— *end note*]
 There can be more than one definition of a class type (Clause
 [[class]]), enumeration type ([[dcl.enum]]), inline function with
+external linkage ([[dcl.inline]]), inline variable with external
+linkage ([[dcl.inline]]), class template (Clause  [[temp]]), non-static
+function template ([[temp.fct]]), static data member of a class
+template ([[temp.static]]), member function of a class template (
 [[temp.mem.func]]), or template specialization for which some template
 parameters are not specified ([[temp.spec]], [[temp.class.spec]]) in a
 program provided that each definition appears in a different translation
 unit, and provided the definitions satisfy the following requirements.
 Given such an entity named `D` defined in more than one translation
   and
 - in each definition of `D`, corresponding names, looked up according
   to  [[basic.lookup]], shall refer to an entity defined within the
   definition of `D`, or shall refer to the same entity, after overload
   resolution ([[over.match]]) and after matching of partial template
+  specialization ([[temp.over]]), except that a name can refer to
+ - a non-volatile `const` object with internal or no linkage if the
+ object
+    - has the same literal type in all definitions of `D`,
+    - is initialized with a constant expression ([[expr.const]]),
+    - is not odr-used in any definition of `D`, and
+    - has the same value in all definitions of `D`,
+    or
+  - a reference with internal or no linkage initialized with a constant
+    expression such that the reference refers to the same entity in all
+    definitions of `D`;
+  and
 - in each definition of `D`, corresponding entities shall have the same
   language linkage; and
 - in each definition of `D`, the overloaded operators referred to, the
   implicit calls to conversion functions, constructors, operator new
   functions and operator delete functions, shall refer to the same
   function, or to a function defined within the definition of `D`; and
 - in each definition of `D`, a default argument used by an (implicit or
   explicit) function call is treated as if its token sequence were
   present in the definition of `D`; that is, the default argument is
+  subject to the requirements described in this paragraph (and, if the
+ default argument has subexpressions with default arguments, this
+ requirement applies recursively).[^3]
 - if `D` is a class with an implicitly-declared constructor (
   [[class.ctor]]), it is as if the constructor was implicitly defined in
   every translation unit where it is odr-used, and the implicit
   definition in every translation unit shall call the same constructor
+  for a subobject of `D`.
+  \[*Example 3*:
   ``` cpp
   // translation unit 1:
   struct X {
     X(int, int);
+    X(int, int, int);
   };
+  X::X(int, int = 0) { }
+  class D {
+ X x = 0;
+  };
+  D d1;                           // X(int, int) called by D()
   // translation unit 2:
   struct X {
     X(int, int);
+    X(int, int, int);
   };
+  X::X(int, int = 0, int = 0) { }
+  class D {
+    X x = 0;
+  };
+  D d2;                           // X(int, int, int) called by D();
+                                  // D()'s implicit definition violates the ODR
   ```
+  — *end example*]
 If `D` is a template and is defined in more than one translation unit,
 then the preceding requirements shall apply both to names from the
 template’s enclosing scope used in the template definition (
 [[temp.nondep]]), and also to dependent names at the point of
 instantiation ([[temp.dep]]). If the definitions of `D` satisfy all

Diff to HTML by rtfpessoa