На лекции про указатели обычно рисуют стрелочки, а потом в лабораторной появляются int **, malloc и Segmentation fault. Указатели перестают пугать, когда видите, что лежит в памяти на каждом шаге. Ниже по порядку: адрес и значение, массивы, функции, динамическая память, двойные указатели и ошибки, которые встречаются в каждой второй работе. Примеры собраны gcc 12 в Linux. Адреса в выводе у вас будут другими и меняются от запуска к запуску.
Адрес и значение

Память можно представить как длинный ряд пронумерованных ячеек по одному байту. У каждой переменной есть значение, то, что в ней лежит, и адрес, номер её первой ячейки. int обычно занимает 4 ячейки подряд.
Указатель это переменная, в которой лежит адрес другой переменной. Нарисуем, адреса условные:
адрес значение имя
1000 42 int x
1008 1000 int *p p хранит адрес x, то есть «указывает на x»
У самого указателя тоже есть адрес (здесь 1008), и в 64-битной системе он занимает 8 байт.
Операторы & и *
#include <stdio.h>
int main(void) {
int x = 42;
int *p = &x;
printf("x = %d\n", x);
printf("&x = %p\n", (void *) &x);
printf("p = %p\n", (void *) p);
printf("*p = %d\n", *p);
*p = 100;
printf("x = %d\n", x);
return 0;
}
x = 42
&x = 0xffffdd282484
p = 0xffffdd282484
*p = 42
x = 100
&xберёт адрес переменной.*pв выражении значит «то, что лежит по адресу изp». Это называется разыменованием.*p = 100пишет вx, хотяxв строке не упоминается.*в объявленииint *pозначает другое: «pэто указатель наint». Один символ с двумя смыслами путает больше всего.
%p печатает адрес, по стандарту ему нужен аргумент типа void *, отсюда приведение.
Указатели и массивы
Имя массива в выражении почти всегда превращается в адрес его первого элемента. Поэтому int *p = a; работает без &, а запись a[i] по определению означает *(a + i).
int a[5] = {10, 20, 30, 40, 50};
int *p = a;
printf("*(p + 2) = %d, p[2] = %d, a[2] = %d\n", *(p + 2), p[2], a[2]);
*(p + 2) = 30, p[2] = 30, a[2] = 30
Но массив не указатель. Разницу показывает sizeof:
sizeof(a) = 20, sizeof(p) = 8
in function: sizeof(a) = 8
Пять int занимают 20 байт, указатель 8. А внутри функции void print_size(int a[]) параметр a уже указатель, хоть и записан с квадратными скобками, и sizeof даёт 8. gcc с -Wall об этом предупреждает: ‘sizeof’ on array function parameter ‘a’ will return size of ‘int *’. Отсюда правило: в функцию вместе с массивом передают его длину отдельным параметром.
Арифметика указателей
p + 1 сдвигается не на один байт, а на один элемент:
p = 0xffffe8e89068
p + 1 = 0xffffe8e8906c
Адреса отличаются на 4, это sizeof(int). Для double * шаг был бы 8. Разность двух указателей на элементы одного массива даёт число элементов между ними: для &a[4] - &a[0] выйдет 4 (печатается через %td).
Выходить за пределы массива этой арифметикой нельзя. Указатель на следующий элемент за последним сравнивать разрешено, разыменовывать уже нет.
Указатель как параметр функции
В C аргументы передаются копией. Функция получает свои копии значений и меняет только их:
void swap_wrong(int a, int b) {
int t = a;
a = b;
b = t;
}
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}
after swap_wrong: x = 1, y = 2
after swap: x = 2, y = 1
swap(&x, &y) получает адреса и меняет то, что по ним лежит, то есть сами x и y. По той же причине scanf("%d", &n) требует &: функция должна записать число в вашу переменную, и ей нужен адрес. Без & она запишет по адресу, равному мусорному значению n, и программа упадёт или испортит память.
malloc и free
Когда размер становится известен только во время работы, память берут из кучи:
int n;
if (scanf("%d", &n) != 1 || n <= 0)
return 1;
int *a = malloc(n * sizeof *a);
if (a == NULL) {
fprintf(stderr, "not enough memory\n");
return 1;
}
for (int i = 0; i < n; i++)
a[i] = i * i;
free(a);
a = NULL;
Что здесь важно:
sizeof *aвместоsizeof(int): если поменяете типa, размер поменяется сам.mallocможет вернутьNULL, результат проверяют.- Память из
mallocне обнулена. Нужны нули, используйтеcalloc(n, sizeof *a). - Каждому
mallocровно одинfree. Забылиfree: утечка. Дваfreeна один блок: ошибка, программа может упасть. a = NULLпослеfreeзащищает от случайного повторного использования.
NULL и неинициализированный указатель
NULL значит «никуда не указывает». Разыменование NULL в Linux и macOS сразу даёт Segmentation fault, и это лучший из вариантов: ошибка видна.
Хуже неинициализированный указатель:
int *p;
*p = 5;
В p мусор, и запись идёт по случайному адресу. У нас программа упала, но может и не упасть, а молча испортить другую переменную. gcc с -Wall предупреждает об этом: ‘p’ is used uninitialized. Правило: объявляете указатель, сразу присваивайте ему адрес или NULL.
Похожая ловушка со строковым литералом. char *s = "hello"; указывает на строку, которую менять нельзя, и s[0] = 'H' у нас закончилось Segmentation fault. Нужна изменяемая строка: char s[] = "hello";, это массив-копия.
Висячие указатели
Висячий указатель хранит адрес памяти, которая уже не принадлежит переменной. Два частых случая.
Адрес локальной переменной из функции. Локальные переменные живут, пока функция не вернула управление:
int *make_counter(void) {
int count = 0;
return &count;
}
Поведение здесь не определено, и это хорошо видно на практике. gcc 12 в Linux предупреждает function returns address of local variable и подставляет вместо адреса NULL: программа печатает (nil) и падает на первой записи. Apple clang на Mac тоже предупреждает, но возвращает настоящий адрес, и та же программа у нас напечатала 5 и завершилась без ошибок. Классическое «у меня работает, а у преподавателя падает». Нужна память, которая переживёт функцию: возвращайте значение, используйте malloc или передавайте указатель на переменную вызывающего.
Использование после free. Указатель после free хранит прежний адрес, но память уже отдана. Чтение или запись по нему может «работать», пока блок не выдадут кому-то ещё. Valgrind пишет об этом Invalid read и указывает, где блок освободили.
Двойные указатели
int **pp это указатель на указатель: в нём лежит адрес переменной, в которой лежит адрес int.
адрес значение имя
1000 42 int x
1008 1000 int *p указывает на x
1016 1008 int **pp указывает на p
*pp это p, **pp это x. Зачем это нужно, видно на функции, которая должна выделить память для вызывающего кода. Типичная ошибка:
void alloc_wrong(int *p, int n) {
p = malloc(n * sizeof *p);
}
p копия указателя. Функция записала адрес в копию, а a в main остался NULL: программа печатает (nil), а valgrind показывает 40 bytes in 1 blocks are definitely lost. Чтобы изменить указатель, нужно передать его адрес:
int read_array(int **out, int *n) {
if (scanf("%d", n) != 1 || *n <= 0)
return 0;
int *a = malloc(*n * sizeof *a);
if (a == NULL)
return 0;
for (int i = 0; i < *n; i++)
scanf("%d", &a[i]);
*out = a;
return 1;
}
Вызов: int *a = NULL; int n; read_array(&a, &n);. Правило: функция меняет T, значит принимает T *. Меняет int *, значит принимает int **.
Второе частое место для ** это динамическая матрица: массив указателей на строки.
int **m = malloc(rows * sizeof *m);
for (int i = 0; i < rows; i++)
m[i] = malloc(cols * sizeof *m[i]);
/* m[i][j] работает как в обычном двумерном массиве */
for (int i = 0; i < rows; i++)
free(m[i]);
free(m);
Освобождают в обратном порядке: сначала строки, потом массив указателей. Если сначала освободить m, адреса строк потеряются вместе с ним. Третий знакомый пример **: параметр char **argv в main, массив строк-аргументов.
Частые ошибки
| Код | Что не так | Как правильно |
|---|---|---|
int *p; *p = 5; |
указатель не инициализирован | int *p = &x; или malloc |
scanf("%d", n); |
передано значение, а не адрес | scanf("%d", &n); |
sizeof(a) в функции |
это размер указателя | передавайте длину параметром |
return &local; |
память исчезнет после выхода | malloc или параметр-указатель |
free(p); free(p); |
двойное освобождение | free(p); p = NULL; |
char *s = "abc"; s[0] = 'A'; |
литерал менять нельзя | char s[] = "abc"; |
if (s1 == s2) для строк |
сравниваются адреса | strcmp(s1, s2) == 0 |
p = malloc(...) внутри функции |
меняется копия указателя | параметр int ** |
Как проверить код с указателями
- Собирайте с
-Wall -Wextra: половину ошибок из таблицы gcc видит при компиляции. - Для поиска во время работы:
gcc -g -fsanitize=address main.c. Санитайзер показывает строку, где случился выход за границу или обращение к освобождённой памяти. - Утечки и неинициализированные значения ищите valgrind:
valgrind --leak-check=full ./main. - Не понимаете, что происходит, рисуйте память таблицей «адрес, значение, имя», как в этой статье, и проходите код по строкам в gdb, печатая
pи*p.
Как с этим помогает Tilpi
В чате задания Tilpi разбирает тему по шагам и объясняет код: можно вставить свою функцию и спросить, почему указатель после вызова остался NULL, а если к заданию приложена лекция, ответ опирается на неё со ссылкой на страницу. Исполнитель собирает и запускает программу в отдельной изолированной машине с gcc, gdb и valgrind, ищет ошибки и предлагает исправления. Чат по своим файлам работает бесплатно с подтверждённой почтой в пределах лимитов, исполнитель на уровне «Быстрая» входит в тариф «Лайт», все уровни открыты с тарифа «Плюс».
