# A.5.6 Pointer arithmetic

**Visual Studio .NET 2003**

In an unsafe context, the `+`

(Section 7.7.4) and `-`

operators (Section 7.7.5) can be applied to values of all pointer types except `void*`

. Thus, for every pointer type `T*`

, the following operators are implicitly defined:

T* operator +(T* x, int y); T* operator +(T* x, uint y); T* operator +(T* x, long y); T* operator +(T* x, ulong y); T* operator +(int x, T* y); T* operator +(uint x, T* y); T* operator +(long x, T* y); T* operator +(ulong x, T* y); T* operator –(T* x, int y); T* operator –(T* x, uint y); T* operator –(T* x, long y); T* operator –(T* x, ulong y); long operator –(T* x, T* y);

Given an expression `P`

of a pointer type `T*`

and an expression `N`

of type `int`

, `uint`

, `long`

, or `ulong`

, the expressions `P`

`+`

`N`

and `N`

`+`

`P`

compute the pointer value of type `T*`

that results from adding `N`

`*`

`sizeof(T)`

to the address given by `P`

. Likewise, the expression `P`

`-`

`N`

computes the pointer value of type `T*`

that results from subtracting `N`

`*`

`sizeof(T)`

from the address given by `P`

.

Given two expressions, `P`

and `Q`

, of a pointer type `T*`

, the expression `P`

`–`

`Q`

computes the difference between the addresses given by `P`

and `Q`

and then divides that difference by `sizeof(T)`

. The type of the result is always `long`

. In effect, `P`

`-`

`Q`

is computed as `((long)(P)`

`-`

`(long)(Q))`

`/`

`sizeof(T)`

.

For example:

using System; class Test { static void Main() { unsafe { int* values = stackalloc int[20]; int* p = &values[1]; int* q = &values[15]; Console.WriteLine("p - q = {0}", p - q); Console.WriteLine("q - p = {0}", q - p); } } }

which produces the output:

p - q = -14 q - p = 14

If a pointer arithmetic operation overflows the domain of the pointer type, the result is truncated in an implementation-defined fashion, but no exceptions are produced.