Путаница вычитания указателя

Question

Когда мы вычитаем указатель из другого указателя, разница не равна количеству байтов, которые они разделены, но равным количеству целых чисел (если указывать на целые числа), они отделены друг от друга. Почему так?

Answer 1

Идея заключается в том, что вы направляете на блоки памяти

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

Если у вас есть int* p = &(array[5]) то *p будет 14. Идя p=p-3 бы *p быть 17.

Так что если у вас есть int* p = &(array[5]) и int *q = &(array[3]), тогда p-q должно быть 2, так как указатели указывают на память, разделенную на 2 блока.

При работе с необработанной памятью (массивы, списки, карты и т. Д.) Нарисуйте много ящиков! Это действительно помогает!

Answer 2

Так что ответ будет одинаковым даже на платформах, где целые числа различной длины.

Answer 3

Скажем у вас есть массив из 10 целых чисел:

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

Затем вы берете указатель на INTArray:

int *p = intArray; 

Тогда вы инкремент p:

p++; 

Что вы бы ожидаем, потому что p начинается в intArray[0], является для приращенного значения p должно быть intArray[1]. Вот почему арифметика указателей работает так. See the code here.

Answer 4

При применении арифметических операций над указателями определенного типа вы всегда хотите, чтобы результирующий указатель указывал на адрес «допустимый» (то есть размер правого шага) адрес памяти относительно исходной точки. Это очень удобный способ доступа к данным в памяти независимо от базовой архитектуры.

Если вы хотите использовать другой «размер шага» вы всегда можете привести указатель к нужному типу:

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

Answer 5

Потому что все в указатель земли о смещениях. Когда вы говорите:

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

То, что вы на самом деле говорят во второй линии:

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

буквально переводится как:

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

И если мы можем добавить 7, чтобы сделать точка смещения в нужное место, мы должны иметь возможность иметь противоположное место, иначе у нас нет симметрии в нашей математике.Если:

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

Тогда для здравомыслия и симметрии:

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

Answer 6

«Когда вы вычитать два указателя, до тех пор, как они указывают на тот же массив, результатом является количество элементов, разделяя их»

Проверить дополнительную информацию here.

Answer 7

@fahad Указатель арифметики проходит по размеру типа данных, который он указывает. Поэтому, когда указатель ur имеет тип int, вы должны ожидать арифметики указателя в размере int (4 байта). Аналогично для указателя char все операции над указатель будет в 1 байт.

Answer 8

Это согласуется с тем, как ведет себя указатель указателя. Это означает, что p1 + (p2 - p1) == p2 *.

Поведение указателя (добавление целого числа к указателю) ведет себя аналогичным образом: p1 + 1 дает вам адрес следующего элемента в массиве, а не следующий байт в массиве - который был бы довольно бесполезным и небезопасным вещь которую нужно сделать.

C мог быть сконструированы таким образом, что добавлены указатели и вычитаться таким же образом, как целые числа, но это означало бы:

• делает p2 = p1 + n * sizeof(*p1) вместо p2 = p1 + n
• делает n = (p2 - p1)/sizeof(*p1) вместо n = p2 - p1

Это приведет к тому, что код будет длиннее, труднее для чтения и менее безопасен.

*: считая, что разница между p1 и p2 является точным кратным типа, на который они указывают. Если они находятся в одном массиве памяти, это будет верно. Если это не так, то мало смысла делать арифметику указателей на них.