Программа на C печатает правильный ответ, а преподаватель запускает её под valgrind и возвращает с пометкой «утечка памяти» или «Invalid read». Ошибки с памятью часто не видны при обычном запуске: запись на байт дальше массива ничего не ломает сегодня, а завтра на другой машине программа падает. Valgrind (точнее, его инструмент Memcheck) следит за каждым обращением к памяти и сообщает о таких ошибках с номером строки. Ниже настоящий отчёт по программе с четырьмя типичными ошибками из лабораторных про динамическую память, разбор каждого сообщения и исправление. Отчёты сняты в Debian 12 с valgrind 3.19; адреса и номера процессов у вас будут другими.
Установка и первый запуск
sudo apt install valgrind
gcc -g -O0 -Wall -Wextra marks.c -o marks
valgrind --leak-check=full ./marks
Флаг -g нужен, чтобы в отчёте были имена файлов и номера строк. -O0 убирает оптимизации, с ними номера строк бывают неточными. Аргументы и ввод передаются как обычно: valgrind --leak-check=full ./marks data.txt < input.txt.
Под valgrind программа работает примерно в 20–30 раз медленнее (Valgrind Quick Start), поэтому проверяйте её на маленьких входных данных. Строки отчёта начинаются с номера процесса вида ==16==, вывод самой программы идёт вперемешку с ними. Длинный отчёт удобно писать в файл: --log-file=vg.txt.
Программа с ошибками
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct student {
char *name;
int *marks;
int count;
};
struct student *make_student(const char *name, int count) {
struct student *s = malloc(sizeof *s);
s->name = malloc(strlen(name));
strcpy(s->name, name);
s->marks = malloc(count * sizeof(int));
s->count = count;
return s;
}
double average(const struct student *s) {
int sum = 0;
for (int i = 0; i <= s->count; i++)
sum += s->marks[i];
return (double) sum / s->count;
}
int main(void) {
struct student *s = make_student("Vera", 3);
s->marks[0] = 5;
s->marks[1] = 4;
printf("%s: %.2f\n", s->name, average(s));
return 0;
}
Компилятор с -Wall -Wextra молчит, программа печатает Vera: 3.00 и завершается с кодом 0. Под valgrind у нас вышло ERROR SUMMARY: 87 errors from 63 contexts, на другой системе число будет другим. Разберём отчёт сверху вниз: нижние сообщения часто оказываются следствием верхних.
Invalid write: запись за концом блока
==16== Invalid write of size 1
==16== at 0x488B408: strcpy (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16== by 0x108897: make_student (marks.c:14)
==16== by 0x10895B: main (marks.c:28)
==16== Address 0x4a6f0a4 is 0 bytes after a block of size 4 alloc'd
==16== at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16== by 0x10887B: make_student (marks.c:13)
==16== by 0x10895B: main (marks.c:28)
Каждое сообщение устроено одинаково:
- Что случилось: запись (
write) размером 1 байт туда, куда нельзя. - Стек вызовов:
atтам, где это произошло,byкто вызвал. Ищите первую строку со своим файлом:make_student (marks.c:14). - Где эта память:
0 bytes after a block of size 4, то есть сразу за концом блока из 4 байт, выделенного в строке 13.
В строке 13 выделено strlen("Vera"), то есть 4 байта, а strcpy копирует 5: четыре буквы и завершающий '\0'. Исправление: malloc(strlen(name) + 1).
Чуть ниже в отчёте есть Invalid read of size 1 внутри strlen и printf с адресом того же блока. Это та же ошибка: строка без места под '\0', и printf читает за её концом. После первого исправления она исчезнет сама.
Invalid read: чтение за концом массива
==16== Invalid read of size 4
==16== at 0x1088F0: average (marks.c:23)
==16== by 0x108993: main (marks.c:31)
==16== Address 0x4a6f0fc is 0 bytes after a block of size 12 alloc'd
==16== at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16== by 0x1088A3: make_student (marks.c:15)
==16== by 0x10895B: main (marks.c:28)
Читаем 4 байта, это один int, сразу за блоком в 12 байт. Блок на три оценки, а цикл i <= s->count берёт четвёртую, marks[3]. Нужно i < s->count. Без valgrind эта ошибка просто подмешивает в сумму случайное число.
Неинициализированное значение и --track-origins
Дальше идут десятки сообщений вида:
==16== Conditional jump or move depends on uninitialised value(s)
==16== at 0x490D830: __printf_fp_l (printf_fp.c:396)
==16== by 0x49169C7: __printf_fp_spec (vfprintf-internal.c:354)
==16== by 0x49169C7: __vfprintf_internal (vfprintf-internal.c:1061)
==16== by 0x490D077: printf (printf.c:33)
==16== by 0x1089A3: main (marks.c:31)
Внутри printf ошибки нет. Memcheck не ругается, когда неинициализированное значение копируют или складывают. Он сообщает, когда от такого значения зависит условный переход, адрес памяти или системный вызов (руководство Memcheck). Мусор попал в sum, оттуда в результат average, и всплыл только при печати числа. Похожие сообщения Use of uninitialised value of size 8 и Syscall param write(buf) points to uninitialised byte(s) в этом отчёте значат то же самое.
Откуда взялся мусор, показывает флаг --track-origins=yes:
valgrind --leak-check=full --track-origins=yes ./marks
==15== Conditional jump or move depends on uninitialised value(s)
==15== at 0x490D830: __printf_fp_l (printf_fp.c:396)
...
==15== by 0x1089A3: main (marks.c:31)
==15== Uninitialised value was created by a heap allocation
==15== at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==15== by 0x1088A3: make_student (marks.c:15)
Мусор пришёл из блока оценок, выделенного в строке 15: marks[2] никто не заполнил, а malloc память не обнуляет. Исправление: заполнить все оценки или выделять через calloc, который обнуляет блок. Если переменная локальная, например int max; без начального значения, valgrind напишет created by a stack allocation и укажет функцию. Флаг замедляет проверку примерно вдвое, поэтому по умолчанию он выключен.
Утечки: definitely, indirectly, possibly, still reachable

В конце отчёта сводка по куче:
==16== HEAP SUMMARY:
==16== in use at exit: 40 bytes in 3 blocks
==16== total heap usage: 4 allocs, 1 frees, 4,136 bytes allocated
==16==
==16== 40 (24 direct, 16 indirect) bytes in 1 blocks are definitely lost in loss record 3 of 3
==16== at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16== by 0x10886B: make_student (marks.c:12)
==16== by 0x10895B: main (marks.c:28)
==16==
==16== LEAK SUMMARY:
==16== definitely lost: 24 bytes in 1 blocks
==16== indirectly lost: 16 bytes in 2 blocks
==16== possibly lost: 0 bytes in 0 blocks
==16== still reachable: 0 bytes in 0 blocks
Структура student занимает 24 байта, на неё указывала только переменная s в main, и при выходе этот указатель пропал. Это definitely lost. Имя (4 байта) и оценки (12 байт) не потеряны сами по себе: указатели на них лежат внутри потерянной структуры. Поэтому они indirectly lost. Одно free(s) не поможет: тогда имя и оценки станут definitely lost. Освобождать нужно изнутри наружу.
Одна аллокация из четырёх в total heap usage не ваша: 4096 байт это буфер, который printf выделяет под стандартный вывод. Библиотека освобождает его сама.
| Вид | Что значит | Что делать |
|---|---|---|
| definitely lost | на блок не осталось ни одного указателя | настоящая утечка, добавьте free |
| indirectly lost | указатели на блок есть только внутри потерянных блоков | исправьте утечку «родителя» и освободите вложенное |
| possibly lost | остался указатель только в середину блока | проверьте, не сдвигали ли вы указатель, полученный от malloc |
| still reachable | указатель жив до конца программы, но free не вызван |
формально не ошибка, но в учебных задачах обычно требуют освобождать всё |
possibly lost получается, например, если сохранить buf + 10 в глобальную переменную, а сам buf потерять. still reachable бывает у глобальных указателей на неосвобождённую память. Подробности по нему valgrind по умолчанию не печатает, их включает --show-leak-kinds=all.
Обращение к освобождённой памяти
Ещё две ошибки, которые встречаются постоянно: чтение после free и повторный free.
==21== Invalid read of size 4
==21== at 0x108840: main (uaf.c:7)
==21== Address 0x4a6f040 is 0 bytes inside a block of size 12 free'd
==21== at 0x4887B40: free (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==21== by 0x10883B: main (uaf.c:6)
==21== Block was alloc'd at
==21== at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==21== by 0x108823: main (uaf.c:4)
==21==
==21== Invalid free() / delete / delete[] / realloc()
Здесь три места сразу: где читали (строка 7), где освободили (строка 6) и где выделили (строка 4). Привычка, которая убирает обе ошибки: после free(p) писать p = NULL. Разыменование NULL падает сразу и честно, а free(NULL) ничего не делает.
Исправленная программа
struct student *make_student(const char *name, int count) {
struct student *s = malloc(sizeof *s);
s->name = malloc(strlen(name) + 1);
strcpy(s->name, name);
s->marks = calloc(count, sizeof(int));
s->count = count;
return s;
}
void free_student(struct student *s) {
free(s->name);
free(s->marks);
free(s);
}
double average(const struct student *s) {
int sum = 0;
for (int i = 0; i < s->count; i++)
sum += s->marks[i];
return (double) sum / s->count;
}
int main(void) {
struct student *s = make_student("Vera", 3);
s->marks[0] = 5;
s->marks[1] = 4;
s->marks[2] = 5;
printf("%s: %.2f\n", s->name, average(s));
free_student(s);
return 0;
}
Vera: 4.67
==15== HEAP SUMMARY:
==15== in use at exit: 0 bytes in 0 blocks
==15== total heap usage: 4 allocs, 4 frees, 4,137 bytes allocated
==15==
==15== All heap blocks were freed -- no leaks are possible
==15==
==15== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Вот такой отчёт и нужен: ноль ошибок и All heap blocks were freed. В реальной программе стоит ещё проверять, что malloc не вернул NULL.
Флаги, которые пригодятся
valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes \
--error-exitcode=1 --log-file=vg.txt ./marks
--leak-check=fullпоказывает, где выделена каждая утечка;--show-leak-kinds=allдобавляетstill reachable;--track-origins=yesищет источник неинициализированных значений;--error-exitcode=1делает код выхода 1, если ошибки нашлись. Удобно в скрипте или Makefile: проверка «упадёт», а не пролистнётся;-qпечатает только ошибки, без шапки и сводки.
Почему не вместе с -fsanitize
Санитайзер -fsanitize=address (ASan) встраивает проверки в саму программу и подменяет malloc. Valgrind тоже подменяет malloc и следит за памятью по-своему. Вместе они не работают. Мы собрали marks.c с -fsanitize=address и запустили под valgrind:
==28== ASan runtime does not come first in initial library list; you should either link runtime to your application or manually preload it with LD_PRELOAD.
==28== HEAP SUMMARY:
==28== in use at exit: 0 bytes in 0 blocks
==28== total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==28==
==28== All heap blocks were freed -- no leaks are possible
Программа даже не запустилась, а сводка выглядит чистой. Поэтому для valgrind собирайте без санитайзеров, для санитайзеров запускайте без valgrind.
У каждого инструмента своя сильная сторона. ASan замедляет программу примерно в 2 раза (документация Clang) и ловит выход за границы массивов в куче, на стеке и в глобальных переменных. Чтения неинициализированной памяти в этом списке нет, его находит valgrind. Если есть время, прогоните программу обоими способами по очереди.
Valgrind на Mac и в Windows
Valgrind официально поддерживает macOS только на Intel и только старые версии, Mac на процессорах Apple в списке нет (платформы Valgrind). Что работает на Mac (мы проверили на macOS 26 с Apple Silicon):
clang -g -fsanitize=address marks.c -o marksнаходит запись за границей и обращение к освобождённой памяти. Поиск утечек в ASan здесь не включается:ASAN_OPTIONS=detect_leaks=1отвечаетdetect_leaks is not supported on this platform.- Утечки показывает утилита
leaksиз инструментов Xcode:leaks --atExit -- ./marks. На маленькой программе с одним забытымmalloc(32)она напечатала1 leak for 48 total leaked bytesи строкуmain + 32 leak.c:4. Размер округлил системный аллокатор, поэтому вместо 32 байт показано 48.
В Windows проще всего поставить WSL: внутри обычный Linux, и valgrind ставится той же командой sudo apt install valgrind.
Как это решает Tilpi
Исполнитель Tilpi собирает и запускает программу в отдельной изолированной машине, где уже стоят gcc, g++, gdb и valgrind, так что проверка памяти доступна и с Mac, и с телефона. Он ищет ошибки, предлагает исправления и собирает отчёт о проверке в Word и PDF. Исполнитель входит во все тарифы: в «Лайт» и «Стандарт» на уровне «Быстрая», в «Плюс» на всех уровнях, а без тарифа работает на «Быстрой» из бесплатных ежемесячных кредитов, общих с чатом.
