Операции над указателями (косвенная адресация)
Указатель может использоваться в выражениях вида
p # ie, ##p, p##, p# = ie,
где: p - указатель, ie - целочисленное выражение, # - символ операции '+' или '-'.
Значением таких выражений является увеличенное или уменьшенное значение указателя на величину ie*sizeof(*p). Следует помнить, что операции с указателями выполняются в единицах памяти того типа объекта, на который ссылается этот указатель.
Текущее значение указателя всегда ссылается на позицию некоторого объекта в памяти с учетом правил выравнивания для соответствующего типа данных. Таким образом, значение p#ie указывает на объект того же типа, расположенный в памяти со смещением на ie позиций.
При сравнении указателей могут использоваться отношения любого вида (">", ">=", "<", "<=", "==", "!="). Наиболее важными видами проверок являются отношения равенства или неравенства.
Отношения порядка имеют смысл только для указателей на последовательно размещенные объекты (элементы одного массива).
Разность двух указателей дает число объектов адресуемого ими типа в соответствующем диапазоне адресов. Очевидно, что уменьшаемый и вычитаемый указатель также должны соответствовать одному массиву, иначе результат операции не имеет практической ценности.
Любой указатель можно сравнивать со значением NULL, которое означает недействительный адрес. Значение NULL можно присваивать указателю как признак пустого указателя. NULL заменяется препроцессором на выражение (void *)0.
Ссылка
Ссылка - это не тип данных, а константный указатель, т.е. это объект, который указывает на положение другой переменной.
Ссылка - это константный указатель, который отличается от переменного указателя тем, что для ссылки не требуется специальной операции разименования. Над указателями возможны арифметические операции. Над ссылкой арифметические операции запрещены, т.к. ссылка декларируется следующим образом:
type &ID = инициализатор;
Инициализатор - это идентификатор объекта, на который в дальнейшем будет указывать ссылка. Пример:
int a = 8;
int &r = a;
Ссылка получила псевдоним объекта указанного в качестве инициализатора. В данном примере, одинаковыми будут следующие действия:
a++;
r++;
12. Массивы
Понятие массива
В математике для удобства записи различных операций часто используют индексированные переменные: векторы, матрицы, тензоры. Так, вектор 
представляется набором чисел (c1 c2....cn), называемых его компонентами, причем каждая компонента имеет свой номер, который принято обозначать в виде индекса. Матрица А – это таблица чисел (аij, i=1,..., m; j=1,..., n), i – номер строки, j – номер столбца. Операции над матрицами и векторами обычно имеют короткую запись, которая обозначает определенные, порой сложные действия над их индексными компонентами. Например, произведения двух векторов записывается как
.
Произведение матрицы на вектор
.
Произведение двух матриц
.
Введение индексированных переменных в языках программирования также позволяет значительно облегчить реализацию многих сложных алгоритмов, связанных с обработкой массивов однотипных данных.
В языке Си для этой цели имеется сложный тип переменных – массив, представляющий собой упорядоченную конечную совокупность элементов одного типа. Число элементов массива называют его размером. Каждый элемент массива определяется идентификатором массива и своим порядковым номером - индексом. Индекс – целое число, по которому производится доступ к элементу массива. Индексов может быть несколько. В этом случае массив называют многомерным, а количество индексов одного элемента массива является его размерностью.
Одномерные массивы
Индексы у одномерных массивов в языке Си начинаются с 0, а в программе одномерный массив объявляется следующим образом:
<тип> < ID_массива>[размер]={список начальных значений};
где: тип – базовый тип элементов (целый, вещественный, символьный);
размер – количество элементов массива.
Список начальных значений используется при необходимости инициализировать данные при объявлении, он может отсутствовать.
Размер массива может задаваться константой или константным выражением. Нельзя задавать массив переменного размера. Для этого существует отдельный механизм – динамическое выделение памяти.
Пример объявления массива целого типа: int a[5];
В массиве «а» первый элемент: а[0], второй – а[1], … пятый - а[4].
Обращение к элементу массива в программе на языке Си осуществляется в традиционном для многих других языков стиле - записи операции обращения по индексу, например:
a[0]=1;
a[i]++;
a[3]=a[i]+a[i+1];
Пример объявления массива целого типа с инициализацией значений:
int a[5]={2, 4, 6, 8, 10};
Если в группе {…} список значений короче, то оставшимся элементам присваивается 0.
Внимание. В языке С с целью повышения быстродействия программы отсутствует механизм контроля границ изменения индексов массивов. При необходимости такой механизм должен быть запрограммирован явно.
Многомерные массивы
Как уже отмечалось, в языке Си кроме одномерных массивов возможна работа с многомерными массивами. Объявление многомерного массива:
<тип> < ID >[размер1][размер2]…[размерN]={{список начальных значений},
{список начальных значений},…};
Наиболее быстро изменяется последний индекс элементов массива, поскольку многомерные массивы в языке Си размещаются в памяти компьютера в последовательности столбцов.
Например, элементы двухмерного массива b[3][2] размещаются в памяти компьютера в следующем порядке:
b[0][0], b[0][1], b[1][0], b[1][1], b[2][0], b[2][1].
Следующий пример иллюстрирует определение массива целого типа, состоящего из трех строк и четырех столбцов, с одновременным присвоением его элементам (инициализацией) начальных значений:
int a[3][4] = {{1,2,0,0},{9,-2,4,1},{-7,0,0,0}};
Если в какой-то группе { } список значений короче, то оставшимся элементам присваивается 0.
Операция sizeof
Данная операция позволяет определить размер объекта по ID или типу, результатом является размер памяти в байтах (тип результата int). Формат записи:
sizeof(параметр);
где: «параметр» – тип или идентификатор объекта (не ID функции).
Если указан идентификатор сложного объекта (массив, структура, объединение), то получаем размер всего сложного объекта. Например:
sizeof(int) ® размер памяти – 2 байта,
int b[5];
sizeof(b) ® размер памяти – 10 байт.
Одно из полезных применений операции sizeof – определение реального количества элементов массива с объявленной размерностью:
char s[256];
int kol = sizeof(s)/sizeof(*s); // количество элементов массива s
Наиболее часто операция sizeof применяется при динамическом распределении памяти:
float *x; // Указатель массива
int n; // Количество элементов массива
x=calloc(n,sizeof(*x)); // Захват и очистка памяти
Применение указателей
Идентификатор массива – это адрес памяти, начиная с которого он расположен, т.е. адрес его первого элемента. Работа с массивами тесно связана с применением указателей.
Пусть объявлены массив a из 5 целочисленных элементов и указатель q на целочисленные переменные:
int a[5], *q;
ID массива a является константным указателем на его начало.
a
| a[0] | a[1] | a[2] | a[3] | a[4] |
Здесь приведено символическое изображение оперативной памяти, выделенной компилятором для объявленного целочисленного массива а[5]. Указатель а содержит адрес его начала в оперативной памяти (ОП), т.е. «символический адрес»=4000 (а=4000).
Если выполнена операция: q=а; - присваивание константы переменной, т.е. q=4000 (аналог: q=&a[0]), то с учетом адресной арифметики выражения а[i] и *(q+i) приводят к одинаковым результатам – обращению к i-му элементу массива.
Идентификаторы а и q - указатели, очевидно, что выражения а[i] и *(а+i) эквивалентны. Отсюда следует, что операция обращения к элементу массива по индексу применима и при его именовании переменной-указателем. Таким образом, для любых указателей можно использовать две эквивалентные формы выражений для доступа к элементам массива: q[i] и *(q+i). Первая форма удобнее для читаемости текста, вторая - эффективнее по быстродействию программы.
Например, для получения значения 4-го элемента массива можно написать а[3] или *(а+3), результат будет один и тот же.
Очевидна эквивалентность выражений:
1) получение адреса начала массива в ОП:
&а[0] « &(*а) « а
2) обращение к первому элементу массива:
*а « а[0]
Последнее объясняет правильность выражения для получения количества элементов массива с объявленной размерностью:
type x[100]; // Размерность должна быть константой
...
int n = sizeof(x) / sizeof(*x);
Указатели, как и переменные любого другого типа, могут объединяться в массивы.
Объявление массива указателей на целые числа имеет вид:
int *a[10], y;
Теперь каждому из элементов массива можно присвоить адрес целочисленной переменной y, например: a[1]=&y;
Чтобы теперь найти значение переменной y через данный элемент массива а, необходимо записать *a[1].
Указатели на указатели
В языке Си можно описать переменную типа «указатель на указатель». Это ячейка оперативной памяти, в которой будет храниться адрес указателя на какую либо переменную. Признак такого типа данных – повторение символа «*» перед идентификатором переменной. Количество символов «*» определяет уровень вложенности указателей друг в друга. При объявлении указателей на указатели возможна их одновременная инициализация. Например:
int a=5;
int *p1=&a;
int **pp1=&p1;
int ***ppp1=&pp1;
Теперь присвоим целочисленной переменной а новое значение, например 10. Одинаковое присваивание произведут следующие операции:
a=10; *p1=10; **pp1=10; ***ppp1=10;
Для доступа к области ОП, отведенной под переменную а можно использовать и индексы. Справедливы следующие аналоги, если мы работаем с многомерными массивами:
*p1 <-> p1[0] **pp1 <-> pp1[0][0] ***ppp1 <-> ppp1[0][0][0]
Отметим, что идентификатор двухмерного массива – это указатель на массив указателей (переменная типа указатель на указатель: int **m;), поэтому выражение а[i][j] эквивалентно выражению *(*(m+i)+j).
Например, двуxмерный массив m[3][4]; компилятор рассматривает как массив четырех указателей, каждый из которых указывает на начало массива со значениями размером по три элемента каждый.
| Указатели | m[0] | ® | m[0][0] | m[0][1] | m[0][2] | m[0][3] | *(*(m+i)+j) |
| m[1] | m[1][0] | m[1][1] | m[1][2] | m[1][3] | |||
| m[2] | m[2][0] | m[2][1] | m[2][2] | m[2][3] |
(А) (В)
Рис. 4
Очевидна и схема размещения такого массива в памяти - последовательное (друг за другом) размещение "строк" - одномерных массивов со значениями. Аналогичным образом можно установить соответствие между указателями и массивами с произвольным числом измерений:
float name[][][][]; « float ****name;
Пример программы конструирования массива массивов:
#include <stdio.h>
int x0[4]={ 1, 2, 3, 4};
int x1[4]={11,12,13, 14}; // Декларация и инициализация
int x2[4]={21,22,23, 24}; // массивов целых чисел
int *y[3]={x0,x1,x2}; // Создание массива указателей
void main(void)
{ int i,j;
for (i=0; i<3; i++)
{ printf("\n %2d)",i);
for (j=0; j<4; j++) printf(" %2d",y[i][j]);
}
}
Результаты работы программы:
0) 1 2 3 4
1) 11 12 13 14
2) 21 22 23 24
Такие же результаты будут получены и при таком объявлении массива:
int y[3][4]={
{ 1, 2, 3, 4},
{11,12,13,14}, // Декларация и инициализация
{21,22,23,24}, // массива массивов целых чисел
};
В последнем случае массив указателей на массивы создается компилятором. Здесь собственно данные массива располагаются в памяти последовательно по строкам, что является основанием для объявления массива y в следующем виде:
int z[3][4]={ 1, 2, 3, 4,
11,12,13,14, // Декларация и инициализация
21,22,23,24}; // массива массивов целых чисел
Замена скобочного выражения z[3][4] на z[12] здесь не допускается, так как массив указателей в данном случае создан не будет.
Адресная функция
Использование многомерных массивов в языке Си связано с расходами оперативной памяти на массивы указателей.
Можно избежать таких расходов, если ввести адресную функцию для доступа к элементам одномерного массива (цепочка одномерных массивов со значениями) по значениям индексов многомерного массива. Например, адресная функция для следующего трехмерного массива x(1..n1, 1..n2, 1..n3) выглядит следующим образом:
L(i, j, k)=n1*n2*(i-1) + n2*(j-1)+k,
где индексы принадлежат диапазонам: i=1..n1, j=1..n2, k=1..n3.
Для размещения такого массива требуется область оперативной памяти размером n1*n2*n3*(число байт отводимых компилятором для одного элемента массива в зависимости от типа данных). Рассматривая такую область как одномерный массив y размером n1*n2*n3 можно установить соответствие элемента массива х элементу памяти для его размещения:
x(i, j, k)=y(L(i, j, k));
Так как массивы являются данными сложного (составного) типа, операции над ними желательно выполнять, используя стандартные библиотечные функции, например, для объявленных массивов: type x[100], y[100]; операция присваивания:
memcpy(x,y,sizeof(x)); - содержимое массива y присвоить содержимому массива x.