3.7. Встроенные макроимена

Теория

Зачем нужен этот пункт

В предыдущих пунктах мы создавали собственные макросы через #define. Но в языке C существуют и заранее определённые макроимена. Они доступны препроцессору без отдельного объявления программистом.

Встроенные макроимена позволяют получить информацию о текущем файле, номере строки, дате и времени препроцессорной обработки, а также о соответствии компилятора стандарту C.

В этом пункте рассматриваются:

Что такое встроенные макроимена

Встроенные макроимена — это заранее определённые имена, которые препроцессор знает без директивы #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;
}

В этом макросе:

Встроенные макроимена и условная компиляция

Встроенные макроимена можно использовать вместе с условной компиляцией.

#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

Такой макрос может существовать в одной среде и отсутствовать в другой. При переносимом коде это нужно учитывать.

Практические рекомендации

Мини-разбор программы

#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;
}

Разберём программу:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое встроенные макроимена?
  2. Почему для __LINE__ не нужно писать собственный #define?
  3. Что подставляется вместо __LINE__?
  4. Что подставляется вместо __FILE__?
  5. Какие значения дают __DATE__ и __TIME__?
  6. Почему __DATE__ и __TIME__ не показывают дату и время запуска программы?
  7. Для чего можно использовать __FILE__ и __LINE__?
  8. Какой спецификатор printf нужен для __FILE__?
  9. Какой спецификатор printf нужен для __LINE__?
  10. Что означает макроимя __STDC__?
  11. Как директива #line влияет на __LINE__ и __FILE__?
  12. Почему не стоит создавать собственные имена с двойными подчёркиваниями?
  13. Чем стандартные встроенные макроимена отличаются от реализационно-зависимых?
  14. Как посмотреть результат раскрытия встроенных макросов через GCC?