When we subtract a pointer from another the diffrence is not equal to how many bytes they are apart but equal to how many integers(if pointing to integers) they are apart.Why so?

So that the answer is the same even on platforms where integers are different lengths.

The idea is that you're pointing to blocks of memory

```
+----+----+----+----+----+----+
| 06 | 07 | 08 | 09 | 10 | 11 | mem
+----+----+----+----+----+----+
| 18 | 24 | 17 | 53 | -7 | 14 | data
+----+----+----+----+----+----+
```

If you have `int* p = &(array[5])`

then `*p`

will be 14. Going `p=p-3`

would make `*p`

be 17.

So if you have `int* p = &(array[5])`

and `int *q = &(array[3])`

, then `p-q`

should be 2, because the pointers are point to memory that are 2 blocks apart.

When dealing with raw memory (arrays, lists, maps, etc) draw lots of boxes! It really helps!

Say you have an array of 10 integers:

```
int intArray[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
```

Then you take a pointer to intArray:

```
int *p = intArray;
```

Then you increment `p`

:

```
p++;
```

What you would expect, because `p`

starts at `intArray[0]`

, is for the incremented value of `p`

to be `intArray[1]`

. That's why pointer arithmetic works like that. See the code here.

When applying arithmetic operations on pointers of a specific type, you always want the resulting pointer to point to a "valid" (meaning the right step size) memory-address relative to the original starting-point. That is a very comfortable way of accessing data in memory independently from the underlying architecture.

If you want to use a different "step-size" you can always cast the pointer to the desired type:

```
int a = 5;
int* pointer_int = &a;
double* pointer_double = (double*)pointer_int; /* totally useless in that case, but it works */
```

Because everything in pointer-land is about offsets. When you say:

```
int array[10];
array[7] = 42;
```

What you're actually saying in the second line is:

```
*( &array[0] + 7 ) = 42;
```

Literally translated as:

```
* = "what's at"
(
& = "the address of"
array[0] = "the first slot in array"
plus 7
)
set that thing to 42
```

And if we can add 7 to make the offset point to the right place, we need to be able to have the opposite in place, otherwise we don't have symmetry in our math. If:

```
&array[0] + 7 == &array[7]
```

Then, for sanity and symmetry:

```
&array[7] - &array[0] == 7
```

"When you subtract two pointers, as long as they point into the same array, the result is the number of elements separating them"

Check for more here.

@fahad Pointer arithmetic goes by the size of the datatype it points.So when ur pointer is of type int you should expect pointer arithmetic in the size of int(4 bytes).Likewise for a char pointer all operations on the pointer will be in terms of 1 byte.