I. Операция получения адреса &
Когда за этим знаком следует имя переменной, результатом операции является адрес указанной переменной.
Пример:
&nurse дает адрес переменной nurse.
II. Операция косвенной адресации
* Когда за этим таком следует указатель на переменную, результатом операции является величнна, помещенная и ячейку с указанным адресом.
Пример:
nurse = 22;pir = &nurse; /* указатель на nurse */ val = *ptr;
Результатом выполнения этого фрагмента является присваивание значения 22 переменной val.
Описание указателей
Мы знаем, как описывать переменные типа int и других типов. Но как описать переменную типа "указатель"? На первый взгляд это можно сделать так:
pointer ptr; /* неправильный способ описания указателя */
Почему нельзя использовать такую запись? Потому что недостаточно сказать, что некоторая переменная является указателем. Кроме этого, необходимо сообщить еще, на переменную какого типа ссылается данный указатель! Причина заключается в том, что переменные разных типов занимают различное число ячеек, в то время как для некоторых операций, связанных с указателями, требуется знать объем отведенной памяти. Ниже приводятся примеры правильного описания указателей:
int *pi; /* указатель на переменную типа целого */
char *рс; /* указатель на символьную переменную */
float *pf, *pg; /* указатели на переменные с плавающей точкой */
Спецификация типа задает тип переменной, на которую ссылается указатель, а символ звездочка (*) определяет саму переменную как указатель. Описание вида int *pi; говорит, что pi - это указатель и что *pi - величина типа int.
РИС. 9.5. Описание и использование указателей.
Точно так же величина (*рс), на которую ссылается переменна рс, имеет тип char. Что можно сказать о самой переменной рс? Мы считаем, что она имеет тип "указатель на переменную типа char". Ее величина, являющаяся адресом,- это целое число без знака, поэтому при выводе на печать значения переменной рс мы будем пользоваться форматом %u.
Использование указателей для связи между функциями
Мы только прикоснулись к обширному и увлекательному миру указателей. Сейчас нашей целью является использование указателей для решения задачи об установлении связи между функциями. Ниже приводится программа, в которой указатели служат средством, обеспечивающим правильную работу функции, которая осуществляет обмен значениями переменных. Посмотрим, как она выглядит, выполним ее, а затем попытаемся понять, как она работает.
/* обмен3 */
main( )
{
int x = 5, у = 10;
printf(" Вначале x = %d и у = %d.\n" , x, у);
interchange(&x,&y); /* передача адресов функции */
printf(" Теперь x = %d и у = %d.\n", x, у);
}
interchange(u, v)
int *u, *v; /* u и v являются указателями */
{
int temp;
temp = *u; /* temp присваивается значение, на которое указывает u */
*u = *v;
*v = temp;
}
После всех встретившихся трудностей, проверим, работает ли этот вариант 1
Вначале x = 5 и y = 10.
Теперь x = 10 и y = 5.
Да программа работает. Посмотрим, как она работает. Во-первых, теперь вызов функции выглядит следующим образом:
interchange(&x, &y);
Вместо передачи значений х и у мы передаем их адреса. Это означает, что формальные аргументы u и v, имеющиеся в спецификации:
interchange(u,v)
при обращении будут заменены адресами и, следовательно, они должны быть описаны как указатели. Поскольку х и у - целого типа, u и v являются указателями на переменные целого типа, и мы вводим следующее описание:
int *u, *v;
Далее в теле функции оператор описания:
int temp;
используется с целью резервирования памяти. Мы хотим поместить значение переменной х в переменную temp, поэтому пишем:
temp = *u;
Вспомните, что значение переменной u - это &х, поэтому переменная u ссылается на х. Это означает, что операция *u дает значение x, которое как раз нам и требуется. Мы не должны писать, например, так:
temp = u; /* неправильно */
поскольку при этом происходит запоминание адреса переменной х, а не ее значения; мы же пытаемся осуществить обмен значениями, а не адресами.
Точно так же, желая присвоить переменной у значение переменной х, мы пользуемся оператором:
*u = *v;
который соответствует оператору
x = y;
Подведем итоги. Нам требовалась функция, которая могла бы изменять значения переменных х и у. Путем передачи функции адресов переменных х и у мы предоставили ей возможность доступа к ним. Используя указатели и операцию *, функция смогла извлечь величины, помещенные в соответствующие ячейки памяти, и поменять их местами.
Вообще говоря, при вызове функции информация о переменной может передаваться функции в двух видах. Если мы используем форму обращения:
function1(х);
происходит передача значения переменной х. Если же мы используем форму обращения:
function2(&x);
происходит передача адреса переменной х. Первая форма обращения требует, чтобы определение функции включало в себя формальный аргумент того же типа, что и х:
functionl(num)
int num;
Вторая форма обращения требует, чтобы определение функции включало в себя формальный аргумент, являющийся указателем на объект соответствующего типа:
function2(ptr)
int *ptr;
Пользуйтесь первой формой, если входное значение необходимо функции для некоторых вычислений или действий, и второй формой, если функция должна будет изменять значения переменных в вызывающей программе. Вторая форма вызова уже применялась при обращении к функции scanf( ). Когда мы хотим ввести некоторое значение в переменную num, мы пишем scanf("%d, &num). Данная функция читает величину, затем, используя адрес, который ей дается, помещает эту величину в память.