Makefile для лабораторной: собрать проект одной командой

Как написать Makefile для проекта на C из нескольких файлов: правила, зависимости, переменные CC и CFLAGS, $@ и $<, clean, .PHONY и ошибка missing separator.

В лабораторной уже три файла, и вы каждый раз набираете gcc -std=c11 -Wall -Wextra -g main.c stack.c queue.c -o lab, а потом ещё строку для запуска с тестовым вводом. В задании при этом написано «проект должен собираться командой make». Makefile записывает эти команды один раз, а утилита make выполняет их и пересобирает только то, что изменилось. Ниже Makefile растёт от одной строки до готового шаблона, и на каждом шаге видно, что make печатает. Примеры проверены на GNU Make 4.3 в Debian 12 и на make 3.81, который стоит на Mac.

Первое правило

Возьмём проект из трёх файлов: main.c, stack.c и заголовок stack.h со стеком. Создайте в папке проекта файл с именем Makefile, без расширения:

lab: main.c stack.c stack.h
	gcc -Wall -Wextra -g main.c stack.c -o lab

Это правило. Слева от двоеточия цель, то есть файл, который нужно получить. Справа зависимости, файлы, из которых он делается. На следующей строке рецепт: команда, которая делает цель. Перед рецептом стоит символ табуляции, не пробелы. Об этом подробнее ниже, это самая частая ошибка.

$ make
gcc -Wall -Wextra -g main.c stack.c -o lab
$ make
make: 'lab' is up to date.

Make печатает каждую команду перед выполнением. Второй запуск ничего не делает: файл lab новее всех зависимостей. Без аргументов make строит первую цель в файле, поэтому главную цель пишите первой.

Как make решает, что пересобирать

Бумажные шестерёнки на войлочной доске, одна шестерёнка новая и ярко-оранжевая, остальные кремовые

Make сравнивает время изменения файлов. Если любая зависимость новее цели, рецепт выполняется. Чтобы при правке одного файла не компилировать все, каждый .c собирают в свой объектный файл .o, а программу линкуют из них:

lab: main.o stack.o
	gcc main.o stack.o -o lab

main.o: main.c stack.h
	gcc -Wall -Wextra -g -c main.c

stack.o: stack.c stack.h
	gcc -Wall -Wextra -g -c stack.c
$ make
gcc -Wall -Wextra -g -c main.c
gcc -Wall -Wextra -g -c stack.c
gcc main.o stack.o -o lab
$ touch stack.c
$ make
gcc -Wall -Wextra -g -c stack.c
gcc main.o stack.o -o lab

После правки stack.c перекомпилировался только он. Make идёт по цепочке: для lab нужен stack.o, stack.o старше stack.c, значит его пересобрать, а потом и lab. На двух файлах выигрыш незаметен, на двадцати он измеряется минутами.

Заголовки тоже зависимости

В правилах выше stack.h стоит в зависимостях обоих .o. Если его забыть, make не узнает о правке заголовка. Проверим: уберём stack.h из правил, соберём, а потом поменяем в заголовке STACK_MAX со 100 на 2.

$ make
make: 'lab' is up to date.
$ ./lab
30
20
10

Make считает, что всё собрано, и программа работает со старым размером стека. После полной пересборки make -B она печатает 20 и 10, как и должна при стеке на два элемента. В настоящем проекте такая рассинхронизация даёт ошибки, которые не воспроизводятся после make clean. Ниже есть способ, при котором gcc сам выписывает зависимости от заголовков.

Переменные: CC, CFLAGS, LDLIBS

Флаги повторяются в каждом правиле. Их выносят в переменные:

CC     = gcc
CFLAGS = -std=c11 -Wall -Wextra -g -O0
LDLIBS = -lm

Значение подставляется записью $(CFLAGS). Имена CC, CFLAGS, LDFLAGS, LDLIBS общепринятые, их же используют встроенные правила make. LDLIBS для библиотек вроде -lm, они идут в конце команды линковки.

Переменную можно переопределить при запуске, не трогая файл: make CFLAGS="-O2 -Wall". Учтите, что make следит только за временем файлов, а не за флагами. Если объектные файлы уже собраны, смена CFLAGS ничего не пересоберёт. Сначала make clean или сразу make -B, который пересобирает всё.

Автоматические переменные и шаблонные правила

Правила для main.o и stack.o одинаковые. Их заменяет одно шаблонное правило:

%.o: %.c stack.h
	$(CC) $(CFLAGS) -c $< -o $@

% совпадает с любой частью имени: правило говорит, как сделать любой .o из одноимённого .c. Внутри рецепта работают автоматические переменные:

Переменная Значение Для main.o: main.c stack.h
$@ цель main.o
$< первая зависимость main.c
$^ все зависимости без повторов main.c stack.h

Список объектных файлов тоже не обязательно писать руками: OBJ = $(SRC:.c=.o) берёт SRC = main.c stack.c и меняет окончания, получается main.o stack.o.

У make есть и встроенное правило для .o из .c. Если для main.o нет своего правила, make всё равно его соберёт командой cc -c -o main.o main.c, но без ваших флагов. Поэтому своё правило с $(CFLAGS) лучше написать явно.

clean, run и .PHONY

Цели не обязаны быть файлами. Удобно завести команды для уборки и запуска:

run: $(TARGET)
	./$(TARGET) < input.txt

clean:
	rm -f $(OBJ) $(TARGET)

.PHONY: run clean

make clean удаляет собранное, make run при необходимости пересобирает программу и запускает её с вводом из файла.

Строка .PHONY говорит make, что run и clean не файлы. Без неё make ищет файл с таким именем, и если в папке случайно оказался файл clean, получится:

$ make clean
make: 'clean' is up to date.

Ничего не удалилось. С .PHONY команда выполняется всегда.

Зависимости от заголовков автоматически

Когда заголовков становится много, выписывать их руками надоедает, и рано или поздно один забудется. gcc умеет сам записывать, какие заголовки подключает каждый файл. Флаг -MMD создаёт рядом с main.o файл main.d, а -MP добавляет в него пустые правила для заголовков, чтобы make не ругался, если заголовок удалят:

$ cat main.d
main.o: main.c stack.h
stack.h:

Остаётся подключить эти файлы в конце Makefile строкой -include $(OBJ:.o=.d). Минус перед include значит «не ошибка, если файлов ещё нет»: при первой сборке их нет.

Ошибка «missing separator» и другие сообщения make

$ make
Makefile:2: *** missing separator.  Stop.

В строке 2 рецепт начинается с пробелов вместо табуляции. Если пробелов ровно восемь, make подсказывает прямо: missing separator (did you mean TAB instead of 8 spaces?). Редакторы часто заменяют Tab на пробелы, а при копировании из браузера табуляция тоже может превратиться в пробелы. Проверить можно командой cat -A Makefile в Linux или cat -et Makefile на Mac: табуляция видна как ^I.

$ cat -A Makefile
lab: main.c stack.c$
    gcc main.c stack.c -o lab$

Здесь ^I нет, значит в начале строки пробелы. В VS Code режим отступа меняется кнопкой «Spaces» в строке состояния внизу окна: выберите «Indent Using Tabs».

Остальные частые сообщения:

Сообщение Причина
No rule to make target 'stak.o', needed by 'lab' опечатка в имени или файл переименован
No targets specified and no makefile found make запущен не в той папке, или файл называется makefile.txt
Nothing to be done for 'all' у цели нет рецепта, или всё уже собрано
'lab' is up to date не ошибка: изменений нет, пересобирать нечего

Готовый Makefile для лабораторной

CC      = gcc
CFLAGS  = -std=c11 -Wall -Wextra -g -O0 -MMD -MP
LDLIBS  = -lm
TARGET  = lab
SRC     = main.c stack.c
OBJ     = $(SRC:.c=.o)

$(TARGET): $(OBJ)
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

run: $(TARGET)
	./$(TARGET) < input.txt

memcheck: $(TARGET)
	valgrind -q --leak-check=full --error-exitcode=1 ./$(TARGET) < input.txt

clean:
	rm -f $(OBJ) $(OBJ:.o=.d) $(TARGET)

.PHONY: run memcheck clean

-include $(OBJ:.o=.d)

Для нового файла в проекте достаточно дописать его в SRC. Цель memcheck прогоняет программу под valgrind и благодаря --error-exitcode=1 завершается ошибкой, если valgrind что-то нашёл. Для C++ замените CC = gcc на CXX = g++, CFLAGS на CXXFLAGS, .c на .cpp и в рецептах $(CC) на $(CXX).

Полезные ключи при запуске:

  • make -n показывает команды, но не выполняет их;
  • make -B пересобирает всё, даже если файлы не менялись;
  • make -j4 собирает до четырёх файлов параллельно;
  • make -C lab3 запускает make в папке lab3.

make на Mac и в Windows

На Mac make ставится вместе с Xcode Command Line Tools (xcode-select --install). Это старый GNU Make 3.81, но всё из этой статьи в нём работает, мы проверили. Отличие только в кавычках сообщений: make: `lab' is up to date.. Команда gcc в Makefile на Mac вызовет clang.

В Windows проще всего собирать в WSL, там make ставится командой sudo apt install make. В MSYS2 есть свой make, а у MinGW он иногда называется mingw32-make.

Как это решает Tilpi

Исполнитель Tilpi работает в отдельной изолированной машине: ставит зависимости, собирает проект, запускает код, пишет и прогоняет тесты. Если сборка падает, он ищет ошибку и предлагает исправление, а в конце собирает отчёт о проверке в Word и PDF. Чат задания пишет и объясняет код, в том числе Makefile. Исполнитель входит во все тарифы: в «Лайт» и «Стандарт» на уровне «Быстрая», в «Плюс» на всех уровнях, а без тарифа работает на «Быстрой» из бесплатных ежемесячных кредитов, общих с чатом.

Запустим ваш код. Даже с телефона.

ИИ-исполнитель соберёт программу в отдельной машине, запустит её и пришлёт вывод и файлы. Ставить компилятор не нужно.

Собрать лабораторную в Tilpi