[expr.add] - C++14 → C++17

Files changed (1) hide show

tmp/tmpfzq0__uv/{from.md → to.md} +26 -48

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

@@ -26,61 +26,39 @@ For subtraction, one of the following shall hold:
 The result of the binary `+` operator is the sum of the operands. The
 result of the binary `-` operator is the difference resulting from the
 subtraction of the second operand from the first.
-For the purposes of these operators, a pointer to a nonarray object
-behaves the same as a pointer to the first element of an array of length
-one with the type of the object as its element type.
 When an expression that has integral type is added to or subtracted from
 a pointer, the result has the type of the pointer operand. If the
-pointer operand points to an element of an array object, and the array
-is large enough, the result points to an element offset from the
-original element such that the difference of the subscripts of the
-resulting and original array elements equals the integral expression. In
-other words, if the expression `P` points to the i-th element of an
-array object, the expressions `(P)+N` (equivalently, `N+(P)`) and
-`(P)-N` (where `N` has the value n) point to, respectively, the i+n-th
-and i-n-th elements of the array object, provided they exist. Moreover,
-if the expression `P` points to the last element of an array object, the
-expression `(P)+1` points one past the last element of the array object,
-and if the expression `Q` points one past the last element of an array
-object, the expression `(Q)-1` points to the last element of the array
-object. If both the pointer operand and the result point to elements of
-the same array object, or one past the last element of the array object,
-the evaluation shall not produce an overflow; otherwise, the behavior is
-undefined.
 When two pointers to elements of the same array object are subtracted,
-the result is the difference of the subscripts of the two array
-elements. The type of the result is an *implementation-defined* signed
-integral type; this type shall be the same type that is defined as
-`std::ptrdiff_t` in the `<cstddef>` header ([[support.types]]). As with
-any other arithmetic overflow, if the result does not fit in the space
-provided, the behavior is undefined. In other words, if the expressions
-`P` and `Q` point to, respectively, the i-th and j-th elements of an
-array object, the expression `(P)-(Q)` has the value i-j provided the
-value fits in an object of type `std::ptrdiff_t`. Moreover, if the
-expression `P` points either to an element of an array object or one
-past the last element of an array object, and the expression `Q` points
-to the last element of the same array object, the expression
-`((Q)+1)-(P)` has the same value as `((Q)-(P))+1` and as
-`-((P)-((Q)+1))`, and has the value zero if the expression `P` points
-one past the last element of the array object, even though the
-expression `(Q)+1` does not point to an element of the array object.
-Unless both pointers point to elements of the same array object, or one
-past the last element of the array object, the behavior is
-undefined.[^26]
 For addition or subtraction, if the expressions `P` or `Q` have type
-“pointer to cv `T`”, where `T` is different from the cv-unqualified
-array element type, the behavior is undefined. In particular, a pointer
-to a base class cannot be used for pointer arithmetic when the array
-contains objects of a derived class type.
-If the value 0 is added to or subtracted from a pointer value, the
-result compares equal to the original pointer value. If two pointers
-point to the same object or both point one past the end of the same
-array or both are null, and the two pointers are subtracted, the result
-compares equal to the value 0 converted to the type `std::ptrdiff_t`.

 The result of the binary `+` operator is the sum of the operands. The
 result of the binary `-` operator is the difference resulting from the
 subtraction of the second operand from the first.
 When an expression that has integral type is added to or subtracted from
 a pointer, the result has the type of the pointer operand. If the
+expression `P` points to element x[i] of an array object `x` with n
+elements, [^25] the expressions `P + J` and `J + P` (where `J` has the
+value j) point to the (possibly-hypothetical) element x[i + j] if
+0 ≤ i + j ≤ n; otherwise, the behavior is undefined. Likewise, the
+expression `P - J` points to the (possibly-hypothetical) element
+x[i - j] if 0 ≤ i - j ≤ n; otherwise, the behavior is undefined.
 When two pointers to elements of the same array object are subtracted,
+the type of the result is an *implementation-defined* signed integral
+type; this type shall be the same type that is defined as
+`std::ptrdiff_t` in the `<cstddef>` header ([[support.types]]). If the
+expressions `P` and `Q` point to, respectively, elements x[i] and x[j]
+of the same array object `x`, the expression `P - Q` has the value
+i - j; otherwise, the behavior is undefined.
+[*Note 1*: If the value i - j is not in the range of representable
+values of type `std::ptrdiff_t`, the behavior is
+undefined. — *end note*]
 For addition or subtraction, if the expressions `P` or `Q` have type
+“pointer to cv `T`”, where `T` and the array element type are not
+similar ([[conv.qual]]), the behavior is undefined.
+[*Note 2*: In particular, a pointer to a base class cannot be used for
+pointer arithmetic when the array contains objects of a derived class
+type. — *end note*]
+If the value 0 is added to or subtracted from a null pointer value, the
+result is a null pointer value. If two null pointer values are
+subtracted, the result compares equal to the value 0 converted to the
+type `std::ptrdiff_t`.

Diff to HTML by rtfpessoa