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

Files changed (1) hide show

tmp/tmpovgyinle/{from.md → to.md} +80 -46

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

@@ -2,47 +2,81 @@
 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. A variable whose
-name appears as a potentially-evaluated expression is *odr-used* unless
-it is an object that satisfies the requirements for appearing in a
-constant expression ([[expr.const]]) and the lvalue-to-rvalue
-conversion ([[conv.lval]]) is immediately applied. `this` is odr-used
-if it appears as a potentially-evaluated expression (including as the
-result of the 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 non-overloaded function whose name appears
-as a potentially-evaluated expression or a member of a set of candidate
-functions, if selected by overload resolution when referred to from a
-potentially-evaluated expression, is odr-used, 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 copy constructor or move constructor
-is odr-used even if the call is actually elided by the implementation.
-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] A copy-assignment function for a class is odr-used
-by an implicitly-defined copy-assignment function for another class as
-specified in  [[class.copy]]. A move-assignment function for a class is
-odr-used by an implicitly-defined 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 as
-specified in  [[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)
@@ -73,12 +107,12 @@ complete class types are required. A class type `T` must be complete if:
   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 `void*`, is converted to the type pointer to `T` or reference to
-  `T` using an implicit 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 (
@@ -110,15 +144,15 @@ unit, then
 - 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
-  `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 value (but not
- the address) of the object is 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
@@ -158,9 +192,9 @@ unit, then
 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
-these requirements, then the program shall behave as if there were a
-single definition of `D`. If the definitions of `D` do not satisfy these
 requirements, then the behavior is undefined.

 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.
+- If `e` has the form `(e1)`, the set contains the potential results of
+  `e1`.
+- If `e` is a glvalue conditional expression ([[expr.cond]]), the set
+  is the union of the sets of potential results of the second and third
+  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
+an expression `e`, where either the lvalue-to-rvalue conversion (
+[[conv.lval]]) is applied to `e`, or `e` is a discarded-value
+expression (Clause [[expr]]). `this` is odr-used if it appears as a
+potentially-evaluated expression (including as the result of the
+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)
   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 (
 - 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
 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
+these requirements, then the behavior is as if there were a single
+definition of `D`. If the definitions of `D` do not satisfy these
 requirements, then the behavior is undefined.

Diff to HTML by rtfpessoa