14. Адресная арифметика

Адресная арифметика – это способ вычисления адреса какого-либо объекта при помощи арифметических операций над указателями, а также использование указателей в операциях. Адресную арифметику также называют арифметикой над указателями.

Арифметика с указателями дает программисту возможность работать с разными типами одинаковым способом. В то же время мощная арифметика с указателями может стать причиной ошибок. Из-за сложностей использования указателей многие современные языки программирования высокого уровня (например, Java или C#) не разрешают прямой доступ к памяти с использованием адресов. В то же время указатели в С – достоинство этого языка, и не зря ОС пишут в основном на С.

Для указателей-переменных разрешены следующие операции: присваивания, сравнение, сложение, вычитание, инкремент ++ и декремент --.

Присваивание мы уже рассмотрели. Вспомним:

1. указателю можно присвоить адрес переменной (не константы и не выражения);

2. указателю можно присвоить указатель того же типа (или другого с приведением типа);

3. указателю типа void * можно присвоить указатель любого типа;

4. любому указателю можно присвоить NULL;

5. указателю нельзя присвоить число. Константа ноль – единственное исключение из этого правила: ее можно присвоить указателю.

Язык С разрешает операцию сравнения указателей одинакового типа, при этом, по сути, сравниваются адреса в памяти.

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

Но при определенных условиях указатели все же можно сравнивать. Если p и q указывают на элементы одного и того же массива, то такие отношения, как <, >= и т.д., работают надлежащим образом. Например, p < q истинно, если p указывает на более ранний элемент массива, чем q. Отношения == и != тоже работают.

Также любой указатель можно осмысленным образом сравнить на равенство или неравенство с NULL.

Но ни за что нельзя ручаться, если вы используете сравнения при работе с указателями, указывающими на разные массивы. Если вам повезет, то на всех машинах вы получите очевидную бессмыслицу. Если же нет, то ваша программа будет правильно работать на одной машине и давать непонятные результаты на другой.

Задача. Какое число в массиве находится раньше: ноль или любое положительное?

void main() {

int a[7] = { -3, 5, 2, 0, -3, 7, 0};

int *p0 = NULL, *p1 = NULL;

int i;

for (i = 0; i < 7; i++) {

if (a[i] == 0 && p0 == NULL)

p0 = &a[i]; // можно находить индексы i0 и i1

if (a[i] > 0 && p1 == NULL)

p1 = &a[i];

}

if (p0 != NULL && p1 != NULL)

printf(“Раньше находится %s\n”, p0 < p1 ? “0” : “>0”);

else {

if (p0 == NULL)

printf(“Нулей в массиве нет\n”);

if (p1 == NULL)

printf(“Положительных в массиве нет\n”);

}

}

Над указателями определены операции сложения и вычитания с целым числом (константой или переменной). Все действия с указателями автоматически учитывают размер объектов, на которые они указывают. Т.е. важной особенностью арифметических операций с указателем является то, что физическое увеличение или уменьшение его значения зависит от типа указателя, т.е. от размера того объекта, на который указатель ссылается.

Если к указателю, описанному как type *p;, прибавляется или отнимается константа N, значение p изменится на N*sizeof(type).

int *p, i = 2;

int a[5] = {1, 2, 3, 4, 5};

p = &a[1]; // *p = 2

p++; // *p = 3, значение p увеличится на 2

p += i; // *p = 5, значение p увеличится на 4

p--; // *p = 4, значение p уменьшится на 2

p += 2; // *p = 2, значение p уменьшится на 4

В этом примере унарная операция p++ увеличивает p так, что он указывает на следующий элемент набора объектов того типа, что задан при определении указателя, а именно int. Здесь операция p += i увеличивает p так, чтобы он указывал на элемент, отстоящий на i элементов от текущего элемента.

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

Унарные операции * и & имеют более высокий приоритет, чем арифметические операции, так что присваивание

y = *ip + 1;

берет объект, на который указывает ip, и добавляет к нему 1, а результат присваивает переменной y. Аналогично

*ip += 1;

увеличивает на единицу объект, на который указывает ip; те же действия выполняют выражения

++*ip;

и

(*ip)++;

В последней записи скобки необходимы, поскольку если их не будет, увеличится значение самого указателя, а не то, на что он указывает. Это обусловлено тем, что унарные операции * и ++ имеют одинаковый приоритет и выполняются справа налево.

Специальное применение имеют указатели на тип void. Указатель на void может указывать на значения любого типа. Однако для выполнения операций над указателем на void либо над указуемым объектом необходимо явно привести тип указателя к типу, отличному от void.

int i[5] = {1, 2, 3, 4, 5};

void *p;

p = &i[1];

//*р = 10; // ошибка!!!

*(int *)р = 10; // правильно и i[1] = 10

//р++;   // ошибка!!!

((int *)р)++; // правильно и p->i[2]

Эти и аналогичные конструкции представляют собой самые простые и самые распространенные формы арифметики указателей или адресной арифметики.

Два указателя на элементы одного и того же массива можно вычитать. Разность двух указателей type *p1, *p2; – это разность их значений, поделенная на sizeof(type), т.е. разность двух указателей – целое число, модуль которого определяет число на 1 большее, чем число элементов массива, расположенных между этими указателями (другими словами, получается разность индексов двух элементов массива). Понятно, что результат может быть отрицательным.

Задача. Какое число в массиве находится раньше: ноль или любое положительное? И сколько элементов массива между ними находится?

if (p0 != NULL && p1 != NULL)

printf(“Раньше находится %s\n”, p0 < p1 ? “0” : “>0”);

int k = p0 < p1 ? p1-p0 : p0-p1;

printf(“Между ними %d элементов\n”, --k);

else {

...

}

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

Объединение в одно целое указателей, массивов и адресной арифметики является одной из наиболее сильных сторон языка С.