4.1. Указатели на объекты
Теория
Зачем нужен этот пункт
В предыдущих главах уже рассматривались базовые типы, переменные, массивы, функции и препроцессорные средства. Теперь начинается одна из самых важных тем языка C — указатели.
Указатель — это переменная, которая хранит адрес другого объекта в памяти. Через указатель можно обратиться к этому объекту косвенно: прочитать его значение или изменить его.
Указатели нужны для:
- передачи данных в функции по адресу;
- работы с массивами и строками;
- динамического выделения памяти;
- работы со структурами;
- создания списков, деревьев и других динамических структур;
- низкоуровневого программирования.
В этом пункте рассматриваются только первые основы:
адрес переменной, объявление указателя, операция &,
операция *, значение NULL и безопасное
начальное использование указателей.
Базовые и производные типы
В языке C есть базовые типы данных: char, int,
float, double, enum, void
и их модификации с short, long,
signed, unsigned.
Кроме базовых типов, в C есть производные типы. Они строятся на основе уже существующих типов.
- массив элементов заданного типа;
- указатель на объект заданного типа;
- функция, возвращающая значение заданного типа.
С массивами и функциями мы уже познакомились в главе 2. Теперь нужно отдельно разобраться с указателями.
Переменная: имя, адрес и значение
Каждая переменная в программе занимает участок памяти. У переменной можно выделить три важных свойства:
- имя — как переменная называется в программе;
- адрес — где переменная находится в памяти;
- значение — какие данные хранятся в этом участке памяти.
int number = 10;
В этой строке:
number— имя переменной;10— значение переменной;- адрес переменной — место в памяти, где хранится это значение.
Обычно программист работает с переменной по имени:
printf("%d\n", number);
number = 25;
Но язык C позволяет получить адрес переменной и работать с ней косвенно — через указатель.
Адрес переменной
Адрес — это числовое значение, которое показывает, где в памяти находится объект программы.
Чтобы получить адрес переменной, используется унарная операция
&.
&имя_переменной
Например:
int number = 10;
printf("%p\n", (void *)&number);
Здесь выражение &number означает «адрес переменной
number».
Для вывода адреса используется спецификатор %p.
В современном корректном C при выводе через %p адрес
обычно приводят к типу void *.
Операция &
Операция & называется операцией взятия адреса.
Она возвращает адрес объекта, который расположен в памяти.
int x = 5;
printf("value = %d\n", x);
printf("address = %p\n", (void *)&x);
Первый вызов printf выводит значение переменной.
Второй вызов выводит адрес переменной.
Операцию & можно применять не ко всему подряд.
Её применяют к объектам, которые действительно имеют место в памяти.
Правильно:
int x = 10;
int *p = &x;
Неправильно:
int *p;
p = &10; /* нельзя взять адрес числового литерала */
p = &(x + 1); /* нельзя взять адрес временного результата выражения */
Что такое указатель
Указатель — это переменная, значением которой является адрес некоторого объекта.
int number = 10;
int *p = &number;
Здесь:
number— обычная переменная типаint;p— указатель на объект типаint;&number— адрес переменнойnumber;p = &number— в указатель записывается адрес переменной.
После этого говорят: p указывает на number.
Объявление указателя
Чтобы объявить указатель, нужно указать тип объекта, на который
он будет указывать, и поставить символ *.
тип *имя_указателя;
Примеры:
char *pc;
int *pi;
float *pf;
double *pd;
Эти объявления читаются так:
pc— указатель наchar;pi— указатель наint;pf— указатель наfloat;pd— указатель наdouble.
Тип указателя показывает, объект какого типа находится по адресу, который хранится в указателе.
Символ * в объявлении и в выражении
Символ * используется в C в разных смыслах.
В объявлении он означает, что объявляется указатель.
int *p;
Эта строка означает: p — указатель на int.
А в выражении *p означает обращение к объекту,
на который указывает p.
int x = 10;
int *p = &x;
printf("%d\n", *p);
Здесь *p означает «значение объекта, адрес которого
хранится в p».
Разыменование указателя
Операция *, применённая к указателю, называется
разыменованием, или косвенной адресацией.
int x = 10;
int *p = &x;
printf("%d\n", *p);
Пошагово:
x— обычная переменная со значением10;&x— адрес переменнойx;pхранит этот адрес;*pобращается к объекту по этому адресу;- поэтому
*pдаёт значениеx.
Если p указывает на x, то чтение
*p похоже на чтение x.
Изменение переменной через указатель
Через разыменованный указатель можно не только читать значение, но и изменять его.
#include <stdio.h>
int main(void)
{
int x = 10;
int *p = &x;
printf("x = %d\n", x);
*p = 25;
printf("x = %d\n", x);
return 0;
}
Результат:
x = 10
x = 25
Оператор:
*p = 25;
означает: записать значение 25 в тот объект, на который
указывает p. Так как p указывает на
x, изменяется именно x.
Один объект — два способа доступа
Если указатель хранит адрес переменной, к одному и тому же участку памяти можно обратиться двумя способами:
- по имени переменной;
- через разыменование указателя.
int value = 100;
int *p = &value;
value = 200;
*p = 300;
И value = 200;, и *p = 300; изменяют
один и тот же объект.
После выполнения всего фрагмента значение value
будет равно 300.
Пример: явная работа с адресом при присваивании
Обычный оператор присваивания:
E = B + C;
можно представить как запись результата выражения в участок памяти,
связанный с переменной E. С помощью указателя это можно
сделать явно.
int E;
int B = 10;
int C = 20;
int *m;
m = &E;
*m = B + C;
Здесь:
m = &E;записывает в указатель адрес переменнойE;*m = B + C;записывает результат выражения в переменнуюEчерез указатель;- после этого
Eбудет равно30.
Такой пример нужен для понимания механизма. В обычной программе
проще написать E = B + C;, но указатели становятся
необходимыми в более сложных задачах.
Указатель должен иметь корректное значение
Указатель сам по себе является переменной. Если его объявить, но не присвоить ему адрес, его значение будет неопределённым.
int *p;
*p = 10; /* опасная ошибка */
Здесь p не указывает на известный объект.
Разыменование такого указателя может привести к повреждению памяти
или аварийному завершению программы.
Правильно:
int x;
int *p = &x;
*p = 10;
Теперь p указывает на существующую переменную x,
поэтому запись через *p корректна.
NULL-указатель
Если указатель пока ни на что не должен указывать, ему можно присвоить
специальное значение NULL.
#include <stdio.h>
int *p = NULL;
NULL означает нулевой указатель — специальное значение,
которое не является адресом обычного объекта.
Перед разыменованием указатель можно проверить:
if (p != NULL)
{
printf("%d\n", *p);
}
Важно: NULL нельзя разыменовывать.
int *p = NULL;
printf("%d\n", *p); /* ошибка */
Инициализация указателя
Хорошая привычка — сразу задавать указателю начальное значение.
int x = 10;
int *p1 = &x;
int *p2 = NULL;
Здесь:
p1сразу указывает на переменнуюx;p2пока ни на что не указывает, но имеет безопасное проверяемое значениеNULL.
Неинициализированный указатель опасен:
int *p; /* значение неизвестно */
*p = 5; /* ошибка */
Тип указателя имеет значение
Указатель связан с типом объекта, на который он указывает.
int x = 10;
double y = 3.14;
int *pi = &x;
double *pd = &y;
pi должен указывать на объект типа int,
а pd — на объект типа double.
Тип нужен компилятору, чтобы понимать:
- сколько байтов занимает объект;
- как правильно читать значение из памяти;
- как правильно записывать значение в память;
- как изменять указатель при операциях
++,--,+,-.
Указатель void *
Особый вид указателя — void *. Такой указатель может
хранить адрес объекта любого типа.
int x = 10;
double y = 3.14;
void *p;
p = &x;
p = &y;
Но указатель void * нельзя напрямую разыменовывать,
потому что тип void означает отсутствие конкретного типа
объекта.
void *p;
int x = 10;
p = &x;
/* printf("%d\n", *p); нельзя */
Чтобы получить значение, нужно привести указатель к нужному типу:
printf("%d\n", *(int *)p);
На начальном этапе void * достаточно понимать как
«обобщённый адрес», который требует аккуратного приведения типа
перед использованием.
Присваивание указателей
Указателю можно присвоить:
- адрес объекта подходящего типа;
- значение другого указателя совместимого типа;
NULL.
int x = 10;
int y = 20;
int *p;
int *q;
p = &x;
q = p;
p = &y;
q = NULL;
После q = p; оба указателя хранят один и тот же адрес.
Это не копирует сам объект, а только копирует адрес.
int x = 10;
int *p = &x;
int *q = p;
*q = 50;
printf("%d\n", x);
После *q = 50; переменная x станет равной
50, потому что p и q указывают
на один объект.
Адрес самого указателя
Указатель — это тоже переменная. Значит, у него есть собственный адрес в памяти.
int x = 10;
int *p = &x;
printf("address of x = %p\n", (void *)&x);
printf("value of p = %p\n", (void *)p);
printf("address of p = %p\n", (void *)&p);
Здесь:
&x— адрес переменнойx;p— значение указателя, то есть адресx;&p— адрес самой переменной-указателяp.
Это разные вещи. p хранит адрес другого объекта,
но сам p тоже где-то хранится в памяти.
Указатель на указатель: первое представление
Так как указатель сам является переменной, можно создать указатель, который хранит адрес другого указателя.
int x = 10;
int *p = &x;
int **pp = &p;
Здесь:
x— обычная переменная;p— указатель наint;pp— указатель на указатель наint.
printf("%d\n", x);
printf("%d\n", *p);
printf("%d\n", **pp);
Все три вывода дадут одно и то же значение. Подробно указатели на указатели будут полезны позже, при работе со строками, массивами указателей и динамической памятью.
Звёздочка относится к конкретному имени
При объявлении нескольких переменных в одной строке важно помнить:
символ * относится к конкретному объявляемому имени,
а не ко всей строке.
int *p, q;
Эта запись означает:
p— указатель наint;q— обычная переменная типаint.
Если нужны два указателя, нужно написать:
int *p, *q;
Для начинающих безопаснее объявлять указатели отдельно:
int *p;
int *q;
Приведение типов указателей
Иногда адрес одного типа явно приводят к указателю другого типа.
int *pi;
char *pc;
pc = (char *)pi;
Такая запись называется приведением типа указателя.
Она говорит компилятору: рассматривать значение pi
как указатель на char.
На начальном этапе к таким преобразованиям нужно относиться осторожно. Приведение типа не меняет реальные данные в памяти. Оно только меняет то, как программа будет интерпретировать адрес.
Неправильное приведение указателей может привести к ошибкам, неправильным значениям и неопределённому поведению.
Базовые операции над указателями
В языке C над указателями допустимы несколько основных операций. На этом этапе важно знать их смысл, даже если подробно они будут использоваться позже.
- присваивание адреса указателю;
- разыменование указателя;
- получение адреса самого указателя;
- сравнение указателей;
- изменение указателя с помощью
++и--; - прибавление или вычитание целого числа;
- вычитание двух указателей внутри одного массива.
Некоторые из этих операций особенно важны при работе с массивами. Поэтому подробно арифметика указателей будет раскрыта в следующем пункте.
Сравнение указателей
Указатели можно сравнивать на равенство и неравенство.
int x = 10;
int y = 20;
int *p = &x;
int *q = &x;
int *r = &y;
if (p == q)
{
printf("p and q point to the same object\n");
}
if (p != r)
{
printf("p and r point to different objects\n");
}
Если два указателя хранят один и тот же адрес, они указывают на один и тот же объект.
Также часто проверяют указатель на NULL:
if (p != NULL)
{
printf("%d\n", *p);
}
Увеличение и уменьшение указателя
К указателю можно применить ++ и --.
Но указатель изменяется не просто на один байт, а на размер объекта,
на который он указывает.
int a[5] = { 10, 20, 30, 40, 50 };
int *p = &a[0];
printf("%d\n", *p);
p++;
printf("%d\n", *p);
Сначала p указывает на a[0].
После p++ он указывает на следующий элемент,
то есть на a[1].
Для int * переход на следующий элемент означает переход
на размер одного int. Для double * — на размер
одного double. Для char * — на размер одного
char.
Арифметика указателей и тип объекта
Тип указателя определяет шаг при арифметике указателей.
char chars[3];
int numbers[3];
double values[3];
char *pc = &chars[0];
int *pi = &numbers[0];
double *pd = &values[0];
pc++;
pi++;
pd++;
Все три операции записаны одинаково, но фактически переход выполняется на разные расстояния в памяти:
pc++переходит к следующемуchar;pi++переходит к следующемуint;pd++переходит к следующемуdouble.
Поэтому указатель — это не просто число. Его тип влияет на смысл операций.
Печать адресов: пример
Конкретные адреса при каждом запуске могут отличаться. Поэтому в учебных программах адреса используют для наблюдения, а не для запоминания конкретных чисел.
#include <stdio.h>
int main(void)
{
int x = 10;
int *p = &x;
printf("x value = %d\n", x);
printf("x address = %p\n", (void *)&x);
printf("p value = %p\n", (void *)p);
printf("p address = %p\n", (void *)&p);
printf("*p value = %d\n", *p);
return 0;
}
Возможный смысл вывода:
x address— адрес переменнойx;p value— значение указателя, то есть тот же адресx;p address— адрес самой переменнойp;*p value— значение объекта, на который указываетp.
Указатель и scanf
С операцией взятия адреса мы уже встречались при вводе через
scanf.
int x;
scanf("%d", &x);
Функция scanf должна записать введённое значение
в переменную x. Поэтому ей нужен адрес этой переменной.
Теперь это можно объяснить через указатели:
&x— адрес переменнойx;scanfполучает этот адрес;- по этому адресу функция записывает введённое значение.
То есть многие функции в C работают с данными именно через адреса.
Мини-программа: обмен значений через указатели
Пока функции с параметрами-указателями будут подробно изучаться позже, но уже сейчас можно увидеть идею изменения данных через адрес.
#include <stdio.h>
int main(void)
{
int a = 10;
int b = 20;
int temp;
int *pa = &a;
int *pb = &b;
printf("before: a = %d, b = %d\n", a, b);
temp = *pa;
*pa = *pb;
*pb = temp;
printf("after: a = %d, b = %d\n", a, b);
return 0;
}
Здесь pa указывает на a, а pb
указывает на b. Обмен выполняется не через имена
a и b, а через разыменованные указатели
*pa и *pb.
Когда указатели особенно полезны
В этом пункте указатели могут выглядеть как усложнение обычной работы с переменными. Например, вместо:
x = 10;
можно написать:
int *p = &x;
*p = 10;
Для такой простой задачи указатель действительно не нужен. Но указатели становятся важными, когда:
- функция должна изменить переменную вызывающего кода;
- нужно эффективно передать большой массив или структуру;
- нужно работать со строками;
- память выделяется во время выполнения программы;
- нужно построить динамическую структуру данных.
Поэтому сейчас главная цель — понять базовую механику: адрес, указатель, разыменование.
Типичные ошибки
Ошибка 1. Разыменование неинициализированного указателя
int *p;
*p = 10;
Указатель p не получил корректный адрес.
Правильно:
int x;
int *p = &x;
*p = 10;
Ошибка 2. Разыменование NULL
int *p = NULL;
printf("%d\n", *p);
NULL означает отсутствие адреса объекта.
Перед разыменованием нужно проверить указатель.
if (p != NULL)
{
printf("%d\n", *p);
}
Ошибка 3. Путаница между p и *p
int x = 10;
int *p = &x;
printf("%p\n", (void *)p); /* адрес */
printf("%d\n", *p); /* значение по адресу */
p — это адрес. *p — это объект по этому адресу.
Ошибка 4. Неправильное объявление нескольких указателей
int *p, q;
Здесь только p является указателем. q —
обычный int. Для двух указателей:
int *p, *q;
Ошибка 5. Попытка взять адрес выражения
int x = 10;
int *p = &(x + 1);
Выражение x + 1 не является отдельной переменной,
у которой можно взять адрес.
Ошибка 6. Несовместимые типы указателей
int x = 10;
double *p = &x;
&x имеет тип «указатель на int»,
а p — указатель на double.
Это разные типы указателей.
Ошибка 7. Неверный формат вывода адреса
int x = 10;
printf("%d\n", &x);
Для адресов используют %p:
printf("%p\n", (void *)&x);
Практические рекомендации
- Всегда инициализируй указатель: адресом объекта или
NULL. - Не разыменовывай указатель, если он равен
NULL. - Не разыменовывай указатель, если не уверен, что он хранит корректный адрес.
- Помни различие:
p— адрес,*p— объект по адресу. - Для вывода адресов используй
%pи приведение кvoid *. - Не объявляй несколько указателей в одной строке, если это может запутать.
- Не приводи типы указателей без необходимости.
- Используй
NULLдля указателя, который временно никуда не указывает. - Проверяй тип объекта, на который должен указывать указатель.
- Сначала уверенно разберись с
&и*, а уже потом переходи к массивам и динамической памяти.
Мини-разбор программы
#include <stdio.h>
int main(void)
{
int value = 15;
int *p = &value;
printf("value = %d\n", value);
printf("address of value = %p\n", (void *)&value);
printf("p = %p\n", (void *)p);
printf("*p = %d\n", *p);
*p = 40;
printf("value after change = %d\n", value);
return 0;
}
Разберём программу:
value— обычная переменная типаint;p— указатель наint;&valueполучает адрес переменнойvalue;p = &valueсохраняет этот адрес в указателе;*pобращается к значению переменнойvalueчерез указатель;*p = 40изменяет переменнуюvalue;- последний вывод показывает, что значение
valueдействительно изменилось.
Что нужно запомнить
- У каждой переменной есть имя, значение и адрес в памяти.
- Операция
&получает адрес объекта. - Указатель — это переменная, которая хранит адрес объекта.
- Тип указателя показывает, объект какого типа находится по адресу.
int *pозначает:p— указатель наint.- Операция
*в выражении разыменовывает указатель. p— адрес,*p— объект по этому адресу.- Через
*pможно читать и изменять объект, на который указываетp. - Неинициализированный указатель разыменовывать нельзя.
NULLозначает, что указатель не указывает на обычный объект.NULLнельзя разыменовывать.void *может хранить адрес объекта любого типа, но его нельзя разыменовывать без приведения типа.- Указатель сам является переменной и имеет собственный адрес.
- При объявлении
int *p, q;указателем является толькоp. - Арифметика указателей зависит от типа объекта, на который указывает указатель.
Самопроверка перед переходом дальше
- Что такое адрес переменной?
- Что делает операция
&? - Что такое указатель?
- Как объявить указатель на
int? - Что означает запись
int *p = &x;? - Чем отличается
pот*p? - Что делает операция разыменования?
- Почему можно изменить переменную через
*p? - Почему опасно разыменовывать неинициализированный указатель?
- Что означает
NULL? - Почему нельзя разыменовывать
NULL? - Что означает тип
void *? - Почему
int *p, q;не объявляет два указателя? - Как вывести адрес переменной через
printf? - Почему тип указателя важен при арифметике указателей?