[conv] - C++11 → C++14

Files changed (1) hide show

tmp/tmpraxi8jc5/{from.md → to.md} +86 -51

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

@@ -34,25 +34,37 @@ types in several contexts:
   initialized is (generally) the destination type. See  [[dcl.init]],
   [[dcl.init.ref]].
 An expression `e` can be *implicitly converted* to a type `T` if and
 only if the declaration `T t=e;` is well-formed, for some invented
-temporary variable `t` ([[dcl.init]]). Certain language constructs
-require that an expression be converted to a Boolean value. An
-expression `e` appearing in such a context is said to be *contextually
-converted to `bool`* and is well-formed if and only if the declaration
-`bool t(e);` is well-formed, for some invented temporary variable `t` (
-[[dcl.init]]). The effect of either implicit conversion is the same as
-performing the declaration and initialization and then using the
 temporary variable as the result of the conversion. The result is an
 lvalue if `T` is an lvalue reference type or an rvalue reference to
 function type ([[dcl.ref]]), an xvalue if `T` is an rvalue reference to
 object type, and a prvalue otherwise. The expression `e` is used as a
 glvalue if and only if the initialization uses it as a glvalue.
-For user-defined types, user-defined conversions are considered as well;
-see  [[class.conv]]. In general, an implicit conversion sequence (
 [[over.best.ics]]) consists of a standard conversion sequence followed
 by a user-defined conversion followed by another standard conversion
 sequence.
 There are some contexts where certain conversions are suppressed. For
@@ -62,26 +74,49 @@ descriptions of those operators and contexts.
 ## Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue ([[basic.lval]]) of a non-function, non-array type `T` can be
 converted to a prvalue.[^1] If `T` is an incomplete type, a program that
-necessitates this conversion is ill-formed. If the object to which the
-glvalue refers is not an object of type `T` and is not an object of a
-type derived from `T`, or if the object is uninitialized, a program that
-necessitates this conversion has undefined behavior. If `T` is a
-non-class type, the type of the prvalue is the cv-unqualified version of
-`T`. Otherwise, the type of the prvalue is `T`.[^2]
-When an lvalue-to-rvalue conversion occurs in an unevaluated operand or
-a subexpression thereof (Clause  [[expr]]) the value contained in the
-referenced object is not accessed. Otherwise, if the glvalue has a class
-type, the conversion copy-initializes a temporary of type `T` from the
-glvalue and the result of the conversion is a prvalue for the temporary.
-Otherwise, if the glvalue has (possibly cv-qualified) type
-`std::nullptr_t`, the prvalue result is a null pointer constant (
-[[conv.ptr]]). Otherwise, the value contained in the object indicated by
-the glvalue is the prvalue result.
 See also  [[basic.lval]].
 ## Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
@@ -257,32 +292,29 @@ represented, the behavior is undefined. If the source type is `bool`,
 the value `false` is converted to zero and the value `true` is converted
 to one.
 ## Pointer conversions <a id="conv.ptr">[[conv.ptr]]</a>
-A *null pointer constant* is an integral constant expression (
-[[expr.const]]) prvalue of integer type that evaluates to zero or a
-prvalue of type `std::nullptr_t`. A null pointer constant can be
-converted to a pointer type; the result is the *null pointer value* of
-that type and is distinguishable from every other value of object
-pointer or function pointer type. Such a conversion is called a *null
-pointer conversion*. Two null pointer values of the same type shall
-compare equal. The conversion of a null pointer constant to a pointer to
-cv-qualified type is a single conversion, and not the sequence of a
-pointer conversion followed by a qualification conversion (
-[[conv.qual]]). A null pointer constant of integral type can be
-converted to a prvalue of type `std::nullptr_t`. The resulting prvalue
-is not a null pointer value.
 A prvalue of type “pointer to *cv* `T`,” where `T` is an object type,
 can be converted to a prvalue of type “pointer to *cv* `void`”. The
-result of converting a “pointer to *cv* `T`” to a “pointer to *cv*
-`void`” points to the start of the storage location where the object of
-type `T` resides, as if the object is a most derived object (
-[[intro.object]]) of type `T` (that is, not a base class subobject). The
-null pointer value is converted to the null pointer value of the
-destination type.
 A prvalue of type “pointer to *cv* `D`”, where `D` is a class type, can
 be converted to a prvalue of type “pointer to *cv* `B`”, where `B` is a
 base class (Clause  [[class.derived]]) of `D`. If `B` is an inaccessible
 (Clause  [[class.access]]) or ambiguous ([[class.member.lookup]]) base
@@ -312,22 +344,23 @@ member of `D` of type *cv* `T`”, where `D` is a derived class (Clause
 of `D`, a program that necessitates this conversion is ill-formed. The
 result of the conversion refers to the same member as the pointer to
 member before the conversion took place, but it refers to the base class
 member as if it were a member of the derived class. The result refers to
 the member in `D`’s instance of `B`. Since the result has type “pointer
-to member of `D` of type *cv* `T`”, it can be dereferenced with a `D`
-object. The result is the same as if the pointer to member of `B` were
-dereferenced with the `B` subobject of `D`. The null member pointer
-value is converted to the null member pointer value of the destination
-type.[^5]
 ## Boolean conversions <a id="conv.bool">[[conv.bool]]</a>
 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to
 member type can be converted to a prvalue of type `bool`. A zero value,
 null pointer value, or null member pointer value is converted to
-`false`; any other value is converted to `true`. A prvalue of type
 `std::nullptr_t` can be converted to a prvalue of type `bool`; the
 resulting value is `false`.
 ## Integer conversion rank <a id="conv.rank">[[conv.rank]]</a>
@@ -363,12 +396,15 @@ Every integer type has an *integer conversion rank* defined as follows:
 The integer conversion rank is used in the definition of the integral
 promotions ([[conv.prom]]) and the usual arithmetic conversions
 (Clause  [[expr]]).
 <!-- Link reference definitions -->
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.lval]: basic.md#basic.lval
 [class.access]: class.md#class.access
 [class.bit]: class.md#class.bit
 [class.conv]: special.md#class.conv
 [class.derived]: class.md#class.derived
 [class.member.lookup]: class.md#class.member.lookup
@@ -391,12 +427,11 @@ promotions ([[conv.prom]]) and the usual arithmetic conversions
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.ref]: dcl.md#dcl.ref
 [expr]: expr.md#expr
-[expr.const]: expr.md#expr.const
-[intro.object]: intro.md#intro.object
 [over.best.ics]: over.md#over.best.ics
 [over.over]: over.md#over.over
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.select]: stmt.md#stmt.select

   initialized is (generally) the destination type. See  [[dcl.init]],
   [[dcl.init.ref]].
 An expression `e` can be *implicitly converted* to a type `T` if and
 only if the declaration `T t=e;` is well-formed, for some invented
+temporary variable `t` ([[dcl.init]]).
+Certain language constructs require that an expression be converted to a
+Boolean value. An expression `e` appearing in such a context is said to
+be *contextually converted to `bool`* and is well-formed if and only if
+the declaration `bool t(e);` is well-formed, for some invented temporary
+variable `t` ([[dcl.init]]).
+Certain language constructs require conversion to a value having one of
+a specified set of types appropriate to the construct. An expression `e`
+of class type `E` appearing in such a context is said to be
+*contextually implicitly converted to* a specified type `T` and is
+well-formed if and only if `e` can be implicitly converted to a type `T`
+that is determined as follows: `E` is searched for conversion functions
+whose return type is *cv* `T` or reference to *cv* `T` such that `T` is
+allowed by the context. There shall be exactly one such `T`.
+The effect of any implicit conversion is the same as performing the
+corresponding declaration and initialization and then using the
 temporary variable as the result of the conversion. The result is an
 lvalue if `T` is an lvalue reference type or an rvalue reference to
 function type ([[dcl.ref]]), an xvalue if `T` is an rvalue reference to
 object type, and a prvalue otherwise. The expression `e` is used as a
 glvalue if and only if the initialization uses it as a glvalue.
+For class types, user-defined conversions are considered as well; see
+[[class.conv]]. In general, an implicit conversion sequence (
 [[over.best.ics]]) consists of a standard conversion sequence followed
 by a user-defined conversion followed by another standard conversion
 sequence.
 There are some contexts where certain conversions are suppressed. For
 ## Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue ([[basic.lval]]) of a non-function, non-array type `T` can be
 converted to a prvalue.[^1] If `T` is an incomplete type, a program that
+necessitates this conversion is ill-formed. If `T` is a non-class type,
+the type of the prvalue is the cv-unqualified version of `T`. Otherwise,
+the type of the prvalue is `T`.[^2]
+When an lvalue-to-rvalue conversion is applied to an expression `e`, and
+either
+- `e` is not potentially evaluated, or
+- the evaluation of `e` results in the evaluation of a member `ex` of
+  the set of potential results of `e`, and `ex` names a variable `x`
+  that is not odr-used by `ex` ([[basic.def.odr]]),
+the value contained in the referenced object is not accessed.
+``` cpp
+struct S { int n; };
+auto f() {
+  S x { 1 };
+  constexpr S y { 2 };
+  return [&](bool b) { return (b ? y : x).n; };
+}
+auto g = f();
+int m = g(false); // undefined behavior due to access of x.n outside its lifetime
+int n = g(true);  // OK, does not access y.n
+```
+In all other cases, the result of the conversion is determined according
+to the following rules:
+- If `T` is (possibly cv-qualified) `std::nullptr_t`, the result is a
+  null pointer constant ([[conv.ptr]]).
+- Otherwise, if `T` has a class type, the conversion copy-initializes a
+  temporary of type `T` from the glvalue and the result of the
+  conversion is a prvalue for the temporary.
+- Otherwise, if the object to which the glvalue refers contains an
+  invalid pointer value ([[basic.stc.dynamic.deallocation]],
+  [[basic.stc.dynamic.safety]]), the behavior is implementation-defined.
+- Otherwise, the value contained in the object indicated by the glvalue
+  is the prvalue result.
 See also  [[basic.lval]].
 ## Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
 the value `false` is converted to zero and the value `true` is converted
 to one.
 ## Pointer conversions <a id="conv.ptr">[[conv.ptr]]</a>
+A *null pointer constant* is an integer literal ([[lex.icon]]) with
+value zero or a prvalue of type `std::nullptr_t`. A null pointer
+constant can be converted to a pointer type; the result is the *null
+pointer value* of that type and is distinguishable from every other
+value of object pointer or function pointer type. Such a conversion is
+called a *null pointer conversion*. Two null pointer values of the same
+type shall compare equal. The conversion of a null pointer constant to a
+pointer to cv-qualified type is a single conversion, and not the
+sequence of a pointer conversion followed by a qualification
+conversion ([[conv.qual]]). A null pointer constant of integral type
+can be converted to a prvalue of type `std::nullptr_t`. The resulting
+prvalue is not a null pointer value.
 A prvalue of type “pointer to *cv* `T`,” where `T` is an object type,
 can be converted to a prvalue of type “pointer to *cv* `void`”. The
+result of converting a non-null pointer value of a pointer to object
+type to a “pointer to *cv* `void`” represents the address of the same
+byte in memory as the original pointer value. The null pointer value is
+converted to the null pointer value of the destination type.
 A prvalue of type “pointer to *cv* `D`”, where `D` is a class type, can
 be converted to a prvalue of type “pointer to *cv* `B`”, where `B` is a
 base class (Clause  [[class.derived]]) of `D`. If `B` is an inaccessible
 (Clause  [[class.access]]) or ambiguous ([[class.member.lookup]]) base
 of `D`, a program that necessitates this conversion is ill-formed. The
 result of the conversion refers to the same member as the pointer to
 member before the conversion took place, but it refers to the base class
 member as if it were a member of the derived class. The result refers to
 the member in `D`’s instance of `B`. Since the result has type “pointer
+to member of `D` of type *cv* `T`”, indirection through it with a `D`
+object is valid. The result is the same as if indirecting through the
+pointer to member of `B` with the `B` subobject of `D`. The null member
+pointer value is converted to the null member pointer value of the
+destination type.[^5]
 ## Boolean conversions <a id="conv.bool">[[conv.bool]]</a>
 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to
 member type can be converted to a prvalue of type `bool`. A zero value,
 null pointer value, or null member pointer value is converted to
+`false`; any other value is converted to `true`. For
+direct-initialization ([[dcl.init]]), a prvalue of type
 `std::nullptr_t` can be converted to a prvalue of type `bool`; the
 resulting value is `false`.
 ## Integer conversion rank <a id="conv.rank">[[conv.rank]]</a>
 The integer conversion rank is used in the definition of the integral
 promotions ([[conv.prom]]) and the usual arithmetic conversions
 (Clause  [[expr]]).
 <!-- Link reference definitions -->
+[basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.lval]: basic.md#basic.lval
+[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [class.access]: class.md#class.access
 [class.bit]: class.md#class.bit
 [class.conv]: special.md#class.conv
 [class.derived]: class.md#class.derived
 [class.member.lookup]: class.md#class.member.lookup
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.ref]: dcl.md#dcl.ref
 [expr]: expr.md#expr
+[lex.icon]: lex.md#lex.icon
 [over.best.ics]: over.md#over.best.ics
 [over.over]: over.md#over.over
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.select]: stmt.md#stmt.select

Diff to HTML by rtfpessoa