[diff.expr] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpe_h5a2wa/{from.md → to.md} +93 -21

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

@@ -1,64 +1,136 @@
 ###  [[expr]]: expressions <a id="diff.expr">[[diff.expr]]</a>
-**Change:** Converting `void*` to a pointer-to-object type requires
-casting.
 ``` cpp
 char a[10];
 void* b=a;
 void foo() {
   char* c=b;
 }
 ```
-ISO C accepts this usage of pointer to `void` being assigned to a
-pointer to object type. C++ does not. **Rationale:** C++ tries harder
-than C to enforce compile-time type safety. **Effect on original
-feature:** Deletion of semantically well-defined feature. Can be
-automated. Violations will be diagnosed by the C++ translator. The fix
-is to add a cast. For example:
 ``` cpp
 char* c = (char*) b;
 ```
-This is fairly widely used but it is good programming practice to add
-the cast when assigning pointer-to-void to pointer-to-object. Some ISO C
-translators will give a warning if the cast is not used.
 **Change:** Decrement operator is not allowed with `bool` operand.
 **Rationale:** Feature with surprising semantics. **Effect on original
-feature:** A valid ISO C expression utilizing the decrement operator on
-a `bool` lvalue (for instance, via the C typedef in `<stdbool.h>`) is
 ill-formed in C++.
 **Change:** In C++, types can only be defined in declarations, not in
 expressions.
 In C, a `sizeof` expression or cast expression may define a new type.
-For example,
 ``` cpp
 p = (void*)(struct x {int i;} *)0;
 ```
-defines a new type, struct `x`. **Rationale:** This prohibition helps to
-clarify the location of definitions in the source code. **Effect on
-original feature:** Deletion of semantically well-defined feature.
-Syntactic transformation. Seldom.
 **Change:** The result of a conditional expression, an assignment
 expression, or a comma expression may be an lvalue. **Rationale:** C++
 is an object-oriented language, placing relatively more emphasis on
 lvalues. For example, function calls may yield lvalues. **Effect on
 original feature:** Change to semantics of well-defined feature. Some C
 expressions that implicitly rely on lvalue-to-rvalue conversions will
-yield different results. For example,
 ``` cpp
 char arr[100];
 sizeof(0, arr)
 ```
-yields `100` in C++ and `sizeof(char*)` in C. Programs must add explicit
-casts to the appropriate rvalue. Rare.

 ###  [[expr]]: expressions <a id="diff.expr">[[diff.expr]]</a>
+**Change:** Converting a prvalue of type “pointer to cv `void`” to a
+pointer-to-object type requires casting.
+[*Example 1*:
 ``` cpp
 char a[10];
 void* b=a;
 void foo() {
   char* c=b;
 }
 ```
+C accepts this usage of “pointer to `void`” being assigned to a pointer
+to object type. C++ does not.
+— *end example*]
+**Rationale:** C++ tries harder than C to enforce compile-time type
+safety. **Effect on original feature:** Deletion of semantically
+well-defined feature. Can be automated. Violations will be diagnosed by
+the C++ translator. The fix is to add a cast.
+[*Example 2*:
 ``` cpp
 char* c = (char*) b;
 ```
+— *end example*]
+Common.
+**Change:** Operations mixing a value of an enumeration type and a value
+of a different enumeration type or of a floating-point type are not
+valid.
+[*Example 3*:
+``` cpp
+enum E1 { e };
+enum E2 { f };
+int b = e <= 3.7;       // valid in C; ill-formed in C++{}
+int k = f - e;          // valid in C; ill-formed in C++{}
+int x = 1 ? e : f;      // valid in C; ill-formed in C++{}
+```
+— *end example*]
+**Rationale:** Reinforcing type safety in C++. **Effect on original
+feature:** Well-formed C code will not compile with this International
+Standard. Violations will be diagnosed by the C++ translator. The
+original behavior can be restored with a cast or integral promotion.
+[*Example 4*:
+``` cpp
+enum E1 { e };
+enum E2 { f };
+int b = (int)e <= 3.7;
+int k = +f - e;
+```
+— *end example*]
+Uncommon.
 **Change:** Decrement operator is not allowed with `bool` operand.
 **Rationale:** Feature with surprising semantics. **Effect on original
+feature:** A valid C expression utilizing the decrement operator on a
+`bool` lvalue (for instance, via the C typedef in `<stdbool.h>`) is
 ill-formed in C++.
 **Change:** In C++, types can only be defined in declarations, not in
 expressions.
 In C, a `sizeof` expression or cast expression may define a new type.
+[*Example 5*:
 ``` cpp
 p = (void*)(struct x {int i;} *)0;
 ```
+defines a new type, struct `x`.
+— *end example*]
+**Rationale:** This prohibition helps to clarify the location of
+definitions in the source code. **Effect on original feature:** Deletion
+of semantically well-defined feature. Syntactic transformation. Seldom.
+**Change:** C allows directly comparing two objects of array type; C++
+does not. **Rationale:** The behavior is confusing because it compares
+not the contents of the two arrays, but their addresses. **Effect on
+original feature:** Deletion of semantically well-defined feature that
+had unspecified behavior in common use cases. Violations will be
+diagnosed by the C++ translator. The original behavior can be replicated
+by explicitly casting either array to a pointer, such as by using a
+unary `+`.
+[*Example 6*:
+``` cpp
+int arr1[5];
+int arr2[5];
+int same = arr1 == arr2;        // valid C, ill-formed C++
+int idem = arr1 == +arr2;       // valid in both C and C++
+```
+— *end example*]
+Rare.
 **Change:** The result of a conditional expression, an assignment
 expression, or a comma expression may be an lvalue. **Rationale:** C++
 is an object-oriented language, placing relatively more emphasis on
 lvalues. For example, function calls may yield lvalues. **Effect on
 original feature:** Change to semantics of well-defined feature. Some C
 expressions that implicitly rely on lvalue-to-rvalue conversions will
+yield different results.
+[*Example 7*:
 ``` cpp
 char arr[100];
 sizeof(0, arr)
 ```
+yields `100` in C++ and `sizeof(char*)` in C.
+— *end example*]
+Programs must add explicit casts to the appropriate rvalue. Rare.

Diff to HTML by rtfpessoa