3.7. Встроенные макроимена
Теория
Зачем нужен этот пункт
В предыдущих пунктах мы создавали собственные макросы через
#define. Но в языке C существуют и заранее определённые
макроимена. Они доступны препроцессору без отдельного объявления
программистом.
Встроенные макроимена позволяют получить информацию о текущем файле, номере строки, дате и времени препроцессорной обработки, а также о соответствии компилятора стандарту C.
В этом пункте рассматриваются:
- что такое встроенные макроимена;
__LINE__— номер текущей строки;__FILE__— имя текущего файла;__DATE__— дата препроцессорной обработки;__TIME__— время начала препроцессорной обработки;__STDC__— признак соответствия стандарту C;- как использовать встроенные макроимена для диагностики;
- как директива
#lineвлияет на__LINE__и__FILE__; - какие ошибки возникают при неправильном использовании встроенных макросов.
Что такое встроенные макроимена
Встроенные макроимена — это заранее определённые имена, которые
препроцессор знает без директивы #define.
Например, программисту не нужно писать:
#define __LINE__ ...
Имя __LINE__ уже известно препроцессору. Когда оно встречается
в исходном тексте, препроцессор заменяет его текущим номером строки.
Основные стандартные встроенные макроимена:
| Макроимя | Что даёт |
|---|---|
__LINE__ |
номер текущей строки исходного файла |
__FILE__ |
имя текущего исходного файла |
__DATE__ |
дату препроцессорной обработки |
__TIME__ |
время начала препроцессорной обработки |
__STDC__ |
признак соответствия компилятора стандарту C |
Почему имена записаны с двойными подчёркиваниями
Встроенные макроимена записываются с двумя символами подчёркивания в начале и в конце:
__LINE__
__FILE__
__DATE__
__TIME__
__STDC__
Такие имена зарезервированы для реализации языка, стандартной библиотеки и компилятора. Обычному программисту не нужно создавать собственные идентификаторы такого вида.
Плохая идея:
int __value__;
#define __MY_MACRO__ 10
Лучше использовать обычные понятные имена:
int value;
#define MY_MACRO 10
Макроимя __LINE__
Макроимя __LINE__ заменяется десятичной целочисленной
константой — номером текущей строки исходного файла.
Нумерация строк начинается с 1.
#include <stdio.h>
int main(void)
{
printf("line = %d\n", __LINE__);
return 0;
}
В строке с вызовом printf макрос __LINE__
будет заменён на номер этой строки в файле.
Например, если вызов находится на строке 5, компилятор после препроцессорной обработки увидит примерно:
printf("line = %d\n", 5);
Пример вывода номера строки
#include <stdio.h>
int main(void)
{
printf("Первая проверка: строка %d\n", __LINE__);
printf("Вторая проверка: строка %d\n", __LINE__);
printf("Третья проверка: строка %d\n", __LINE__);
return 0;
}
Каждый раз __LINE__ заменяется номером той строки,
где он написан. Поэтому значения в трёх строках будут разными.
Макроимя __FILE__
Макроимя __FILE__ заменяется строковым литералом,
содержащим имя текущего исходного файла.
#include <stdio.h>
int main(void)
{
printf("file = %s\n", __FILE__);
return 0;
}
Если файл называется main.c, после препроцессорной обработки
строка может выглядеть примерно так:
printf("file = %s\n", "main.c");
Конкретный вид имени зависит от компилятора и способа запуска сборки. Иногда выводится только имя файла, иногда — путь к файлу.
__FILE__ и подключаемые файлы
При обработке файлов, подключённых через #include,
значение __FILE__ временно меняется на имя подключаемого
файла. После завершения включения препроцессор возвращается к
предыдущему файлу.
Например, проект:
main.c
debug_info.h
Файл debug_info.h:
printf("inside header: %s\n", __FILE__);
Файл main.c:
#include <stdio.h>
int main(void)
{
printf("before include: %s\n", __FILE__);
#include "debug_info.h"
printf("after include: %s\n", __FILE__);
return 0;
}
Во время обработки подключённого файла __FILE__ будет
относиться к заголовку, а после возвращения — снова к основному файлу.
На практике не стоит вставлять исполняемые операторы через заголовки
таким образом. Этот пример нужен только для понимания работы
__FILE__.
Макроимя __DATE__
Макроимя __DATE__ заменяется строковым литералом,
содержащим дату препроцессорной обработки исходного файла.
Формат обычно такой:
"Mmm dd yyyy"
Например:
"Mar 10 2011"
Пример программы:
#include <stdio.h>
int main(void)
{
printf("build date: %s\n", __DATE__);
return 0;
}
Если программа была собрана 10 марта 2011 года, после обработки получится примерно:
printf("build date: %s\n", "Mar 10 2011");
Макроимя __TIME__
Макроимя __TIME__ заменяется строковым литералом,
содержащим время начала препроцессорной обработки.
Формат:
"hh:mm:ss"
Пример:
#include <stdio.h>
int main(void)
{
printf("build time: %s\n", __TIME__);
return 0;
}
После препроцессорной обработки строка может стать такой:
printf("build time: %s\n", "14:35:08");
Значение __TIME__ фиксируется при сборке программы,
а не меняется каждую секунду во время выполнения.
__DATE__ и __TIME__ — это время сборки, а не время запуска
Важно не путать дату и время сборки с датой и временем запуска программы.
printf("build date: %s\n", __DATE__);
printf("build time: %s\n", __TIME__);
Эти значения вставляются в программу во время препроцессорной обработки.
Если скомпилировать программу один раз, а запускать её несколько дней,
значения __DATE__ и __TIME__ останутся прежними.
Чтобы получить текущую дату и время во время выполнения программы,
используют функции из заголовочного файла time.h.
Это уже не работа препроцессора, а обычная работа программы.
Макроимя __STDC__
Макроимя __STDC__ связано с режимом соответствия стандарту C.
В классическом описании оно равно 1, если компилятор работает
в соответствии с ANSI-стандартом C.
#include <stdio.h>
int main(void)
{
#ifdef __STDC__
printf("__STDC__ is defined\n");
printf("__STDC__ = %d\n", __STDC__);
#else
printf("__STDC__ is not defined\n");
#endif
return 0;
}
На современных компиляторах значение и наличие этого макроса могут зависеть от режима компиляции и настроек компилятора.
Поэтому __STDC__ обычно используют не для обычной логики
программы, а для проверки режима трансляции или совместимости.
Дополнительные стандартные макросы современных версий C
В современных стандартах C могут встречаться и другие предопределённые макросы. Например:
| Макроимя | Смысл |
|---|---|
__STDC_VERSION__ |
версия стандарта C, если компилятор сообщает такую информацию |
__STDC_HOSTED__ |
признак обычной hosted-среды с полной стандартной библиотекой |
Например:
#ifdef __STDC_VERSION__
printf("C standard version: %ld\n", __STDC_VERSION__);
#endif
Для базового курса достаточно уверенно знать основные имена:
__LINE__, __FILE__, __DATE__,
__TIME__ и __STDC__.
Реализационно-зависимые встроенные макросы
Кроме стандартных встроенных макроимён, компиляторы часто определяют собственные дополнительные макросы.
Например, в разных средах могут встречаться имена, связанные с:
- операционной системой;
- архитектурой процессора;
- версией компилятора;
- режимом сборки;
- расширениями конкретной реализации.
Примеры таких имён:
_WIN32
__linux__
__GNUC__
_MSC_VER
Эти имена не являются одинаковыми для всех компиляторов. Их нужно использовать аккуратно и только тогда, когда программа действительно зависит от конкретной платформы или компилятора.
Пример: диагностический вывод
Встроенные макроимена удобно использовать для диагностических сообщений. Например, можно вывести файл и строку, в которой возникла проверка.
#include <stdio.h>
int main(void)
{
int value = -5;
if (value < 0)
{
printf("Ошибка: value < 0\n");
printf("Файл: %s\n", __FILE__);
printf("Строка: %d\n", __LINE__);
}
return 0;
}
Такой вывод помогает быстрее найти место в исходном коде, где была обнаружена проблема.
Макрос для вывода места в программе
Можно создать собственный макрос, который использует встроенные макроимена.
#include <stdio.h>
#define PRINT_LOCATION() \
printf("file: %s, line: %d\n", __FILE__, __LINE__)
int main(void)
{
PRINT_LOCATION();
return 0;
}
При вызове PRINT_LOCATION() будет выведено имя файла
и номер строки, где этот макрос был раскрыт.
Обрати внимание: __LINE__ подставляется в том месте,
где макрос раскрывается, а не обязательно там, где он был определён.
Макрос проверки условия
На основе __FILE__ и __LINE__ можно сделать
простой макрос проверки.
#include <stdio.h>
#define CHECK(condition) \
do \
{ \
if (!(condition)) \
{ \
printf("CHECK failed: %s\n", #condition); \
printf("file: %s\n", __FILE__); \
printf("line: %d\n", __LINE__); \
} \
} while (0)
int main(void)
{
int x = -10;
CHECK(x > 0);
return 0;
}
В этом макросе:
#conditionпревращает условие в строку;__FILE__сообщает имя файла;__LINE__сообщает строку, где была выполнена проверка;do { ... } while (0)делает макрос похожим на один оператор.
Встроенные макроимена и условная компиляция
Встроенные макроимена можно использовать вместе с условной компиляцией.
#ifdef __STDC__
printf("Standard C mode\n");
#else
printf("Non-standard C mode\n");
#endif
Или так:
#ifdef __STDC_VERSION__
printf("C version: %ld\n", __STDC_VERSION__);
#else
printf("C version is unknown\n");
#endif
Это позволяет проверять возможности компилятора ещё на этапе препроцессорной обработки.
Директива #line и встроенные макроимена
Директива #line влияет на значения __LINE__
и __FILE__.
#include <stdio.h>
int main(void)
{
printf("%s:%d\n", __FILE__, __LINE__);
#line 100 "virtual_file.c"
printf("%s:%d\n", __FILE__, __LINE__);
return 0;
}
До директивы #line будут использоваться реальные имя файла
и номер строки. После директивы следующая строка будет считаться
строкой 100 файла virtual_file.c.
Это нужно редко, но важно понимать связь: #line меняет
информацию, которую затем возвращают __LINE__ и
__FILE__.
Пример: информация о сборке программы
С помощью __DATE__ и __TIME__ можно вывести
информацию о том, когда программа была собрана.
#include <stdio.h>
int main(void)
{
printf("Program build information\n");
printf("File: %s\n", __FILE__);
printf("Build date: %s\n", __DATE__);
printf("Build time: %s\n", __TIME__);
return 0;
}
Такой вывод может быть полезен в учебных работах, демонстрационных программах и при отладке, когда нужно понять, какая версия программы была запущена.
Пример: простой лог
Встроенные макроимена можно использовать для логирования.
#include <stdio.h>
#define LOG(message) \
printf("[LOG] %s:%d: %s\n", __FILE__, __LINE__, (message))
int main(void)
{
LOG("program started");
int x = 10;
LOG("value initialized");
printf("x = %d\n", x);
LOG("program finished");
return 0;
}
Каждый вызов LOG выведет сообщение, имя файла и номер строки,
где этот вызов находится.
Важное ограничение __LINE__ внутри макросов
Значение __LINE__ зависит от места раскрытия макроса.
Это удобно для диагностики, но нужно понимать, где именно происходит
подстановка.
#define SHOW_LINE() printf("line = %d\n", __LINE__)
int main(void)
{
SHOW_LINE();
SHOW_LINE();
return 0;
}
Два вызова SHOW_LINE() выведут разные номера строк,
потому что макрос раскрывается в разных местах.
Если несколько вызовов записать в одной строке, значение может быть одинаковым:
SHOW_LINE(); SHOW_LINE();
Оба раскрытия находятся на одной физической строке исходного файла.
Встроенные макросы нельзя использовать как переменные
Встроенные макроимена не являются переменными. Их нельзя изменять во время выполнения программы.
Нельзя:
__LINE__ = 10;
__LINE__ — это препроцессорная подстановка. После обработки
она превращается в число, а число не может быть левой частью присваивания.
Нельзя ожидать, что __DATE__ или __TIME__
обновятся во время работы программы. Они вставляются один раз
при сборке.
Не переопределяй встроенные макроимена
Не нужно пытаться переопределять встроенные макроимена через
#define или отменять их через #undef.
Плохая идея:
#define __LINE__ 100
#undef __FILE__
Такие имена относятся к области, зарезервированной для компилятора и стандартной реализации. Попытки переопределения могут привести к предупреждениям, ошибкам или непереносимому поведению.
Если нужно собственное имя, используй обычный макрос:
#define PROJECT_NAME "CourseProject"
Как посмотреть раскрытие встроенных макросов
Как и другие макросы, встроенные макроимена можно увидеть после препроцессорной обработки.
gcc -E main.c -o main.i
Если в файле было:
printf("%s:%d\n", __FILE__, __LINE__);
то в файле после препроцессора можно увидеть уже подставленные значения:
printf("%s:%d\n", "main.c", 5);
Точные значения зависят от имени файла, номера строки и момента сборки.
Типичные ошибки
Ошибка 1. Ожидание, что __TIME__ показывает текущее время
printf("%s\n", __TIME__);
__TIME__ показывает время препроцессорной обработки,
то есть время сборки, а не текущее время запуска программы.
Ошибка 2. Ожидание, что __DATE__ изменяется каждый день автоматически
printf("%s\n", __DATE__);
Если программа не была пересобрана, значение останется старым. Чтобы обновить дату сборки, программу нужно скомпилировать заново.
Ошибка 3. Использование неправильного формата вывода
printf("%d\n", __FILE__);
__FILE__ — это строковый литерал, поэтому нужен
спецификатор %s.
printf("%s\n", __FILE__);
Ошибка 4. Использование %s для __LINE__
printf("%s\n", __LINE__);
__LINE__ — это целочисленная константа, поэтому нужен
спецификатор %d.
printf("%d\n", __LINE__);
Ошибка 5. Попытка переопределить встроенное имя
#define __FILE__ "test.c"
Не нужно переопределять зарезервированные встроенные макроимена.
Ошибка 6. Считать реализационно-зависимые макросы универсальными
#ifdef _MSC_VER
printf("MSVC\n");
#endif
Такой макрос может существовать в одной среде и отсутствовать в другой. При переносимом коде это нужно учитывать.
Практические рекомендации
- Используй
__FILE__и__LINE__для диагностических сообщений. - Используй
__DATE__и__TIME__для вывода даты и времени сборки. - Не путай время сборки и время запуска программы.
- Для
__FILE__,__DATE__,__TIME__используй формат%s. - Для
__LINE__используй формат%d. - Не создавай собственные имена с двойными подчёркиваниями.
- Не переопределяй встроенные макроимена.
- Реализационно-зависимые макросы проверяй через
#ifdefили#if defined(...). - Если используешь
#line, помни, что он влияет на__LINE__и__FILE__. - Для просмотра результата подстановки можно использовать
gcc -E.
Мини-разбор программы
#include <stdio.h>
#define LOG(message) \
printf("[LOG] %s:%d: %s\n", __FILE__, __LINE__, (message))
int main(void)
{
printf("Build date: %s\n", __DATE__);
printf("Build time: %s\n", __TIME__);
#ifdef __STDC__
printf("Standard C mode: %d\n", __STDC__);
#endif
LOG("program started");
int value = 10;
if (value > 0)
{
LOG("value is positive");
}
printf("value = %d\n", value);
LOG("program finished");
return 0;
}
Разберём программу:
__DATE__выводит дату сборки программы;__TIME__выводит время сборки программы;__STDC__проверяется через условную компиляцию;LOG(message)использует__FILE__и__LINE__;- каждый вызов
LOGвыводит место в исходном файле, где он был раскрыт; - все эти значения подставляются препроцессором до компиляции.
Что нужно запомнить
- Встроенные макроимена заранее известны препроцессору.
__LINE__заменяется номером текущей строки.__FILE__заменяется строкой с именем текущего файла.__DATE__заменяется строкой с датой препроцессорной обработки.__TIME__заменяется строкой со временем начала препроцессорной обработки.__STDC__связан с режимом соответствия стандарту C.__DATE__и__TIME__показывают время сборки, а не время запуска программы.__FILE__,__DATE__и__TIME__являются строковыми литералами.__LINE__является целочисленной константой.- Директива
#lineможет изменить значения, связанные с__LINE__и__FILE__. - Компиляторы могут определять дополнительные собственные макросы.
- Имена с двойными подчёркиваниями не нужно использовать для собственных переменных и макросов.
Самопроверка перед переходом дальше
- Что такое встроенные макроимена?
- Почему для
__LINE__не нужно писать собственный#define? - Что подставляется вместо
__LINE__? - Что подставляется вместо
__FILE__? - Какие значения дают
__DATE__и__TIME__? - Почему
__DATE__и__TIME__не показывают дату и время запуска программы? - Для чего можно использовать
__FILE__и__LINE__? - Какой спецификатор
printfнужен для__FILE__? - Какой спецификатор
printfнужен для__LINE__? - Что означает макроимя
__STDC__? - Как директива
#lineвлияет на__LINE__и__FILE__? - Почему не стоит создавать собственные имена с двойными подчёркиваниями?
- Чем стандартные встроенные макроимена отличаются от реализационно-зависимых?
- Как посмотреть результат раскрытия встроенных макросов через GCC?