The
usual arithmetic conversions are performed for operands of arithmetic or
enumeration type.

additive-expression:multiplicative-expressionadditive-expression+multiplicative-expressionadditive-expression-multiplicative-expression

For addition, either both operands shall have arithmetic or unscoped enumeration
type, or one operand shall be a pointer to a completely-defined object
type and the other shall have integral or unscoped enumeration type.

For subtraction, one of the following shall hold:

- both operands are pointers to cv-qualified or cv-unqualified versions of the same completely-defined object type; or
- the left operand is a pointer to a completely-defined object type and the right operand has integral or unscoped enumeration type.

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,86
the expressions P + J and J + P
(where J has the value j)
point to the (possibly-hypothetical) element
if ;
otherwise, the behavior is undefined.

Likewise, the expression P - J
points to the (possibly-hypothetical) element
if ;
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 ;
otherwise, the behavior is undefined.

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.

An object that is not an array element is considered to belong to a
single-element array for this purpose; see [expr.unary.op].

A pointer past the last element of an array x of n elements
is considered to be equivalent to a pointer to a hypothetical element
x[n] for this purpose; see [basic.compound].