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

Препроцессор C/C++ (англ. pre processor, предобработчик) — программа, подготавливающая код программы на языке C/C++ к компиляции.

Основные функции препроцессора[править | править код]

Препроцессором выполняются следующие действия:

• замена соответствующих диграфов и триграфов на эквивалентные символы «#» и «»;
• удаление экранированных символов перевода строки;
• замена строчных и блочных комментариев пустыми строками (с удалением окружающих пробелов и символов табуляции);
• вставка (включение) содержимого произвольного файла (#include);
• макроподстановки (#define);
• условная компиляция (#if, #ifdef, #elif, #else, #endif);
• вывод сообщений (#warning, #error).

Условная компиляция позволяет выбрать код для компиляции в зависимости от:

• модели процессора (платформы);
• разрядности адресов;
• размерности типов;
• наличия/отсутствия поддержки расширений языка;
• наличия/отсутствия библиотек и/или функций;
• особенностей поведения конкретных функций;
• и другого.

Этапы работы препроцессора:

• лексический анализ кода C/C++ (синтаксический анализ не выполняется);
• обработка директив;
• выполнение подстановок:
  • диграфов и триграфов;
  • комментариев;
  • директив;
  • лексем, заданных директивами.

Язык препроцессора C/C++ не является полным по Тьюрингу хотя бы потому, что с помощью директив невозможно заставить препроцессор зависнуть. См. рекурсивная функция (теория вычислимости).

Синтаксис директив[править | править код]

Директивой (командной строкой) препроцессора называется строка в исходном коде, имеющая следующий формат: #ключевое_слово параметры:

• символ #;
• ноль или более символов пробелов и/или табуляции;
• одно из предопределённых ключевых слов;
• параметры, зависимые от ключевого слова.

Список ключевых слов:

• define — создание константы или макроса;
• undef — удаление константы или макроса;
• include — вставка содержимого указанного файла;
• if — проверка истинности выражения;
• ifdef — проверка существования константы или макроса;
• ifndef — проверка несуществования константы или макроса;
• else — ветка условной компиляции при ложности выражения if;
• elif — проверка истинности другого выражения; краткая форма записи для комбинации else и if;
• endif — конец ветки условной компиляции;
• line — указание имени файла и номера текущей строки для компилятора;
• error — вывод сообщения и остановка компиляции;
• warning — вывод сообщения без остановки компиляции;
• pragma — указание действия, зависящего от реализации, для препроцессора или компилятора;
• если ключевое слово не указано, директива игнорируется;
• если указано несуществующее ключевое слово, выводится сообщение об ошибке и компиляция прерывается. (В некоторых компиляторах, таких как g++, компиляция продолжается, просто показывая предупреждение.)

Описание директив[править | править код]

Вставка файлов (#include)[править | править код]

При обнаружении директив #include "..." и #include <...>, где «…» — имя файла, препроцессор читает содержимое указанного файла, выполняет директивы и замены (подстановки), заменяет директиву #include на директиву #line и обработанное содержимое файла.

Для #include "..." поиск файла выполняется в текущей папке и папках, указанных в командной строке компилятора. Для #include <...> поиск файла выполняется в папках, содержащих файлы стандартной библиотеки (пути к этим папкам зависят от реализации компилятора).

При обнаружении директивы #include последовательность-лексем , не совпадающей ни с одной из предыдущих форм, рассматривает последовательность лексем как текст, который в результате всех макроподстановок должен дать #include <...> или #include "...". Сгенерированная таким образом директива далее будет интерпретироваться в соответствии с полученной формой.

Включаемые файлы обычно содержат:

• объявления функций;
• объявления глобальных переменных;
• определения интерфейсов;
• определения типов данных;
• и другое.

Директива #include обычно указывается в начале файла (в заголовке), поэтому включаемые файлы называются заголовочными.

Пример включения файлов из стандартной библиотеки языка C.

#include <math.h> // включение объявлений математических функций
#include <stdio.h> // включение объявлений функций ввода-вывода

Использование препроцессора считается неэффективным по следующим причинам:

• каждый раз при включении файлов выполняются директивы и замены (подстановки); компилятор мог бы сохранять результаты препроцессирования для использования в будущем;
• множественные включения одного файла приходится предотвращать вручную с помощью директив условной компиляции; компилятор мог бы выполнять эту задачу самостоятельно.

Начиная с 1970-х годов стали появляться способы, заменившие включение файлов. В языках Java и Common Lisp используются пакеты (ключевое слово package) (см. package в Java), в языке Паскаль — англ. units (ключевые слова unit и uses), в языках Modula, OCaml, Haskell и Python — модули. В языке D, разработанном для замены языков C и C++, используется ключевые слова module и import.

Константы и макросы #define[править | править код]

Константы и макросы препроцессора используются для определения небольших фрагментов кода.

// константа
#define BUFFER_SIZE 1024

// макрос
#define NUMBER_OF_ARRAY_ITEMS( array ) ( sizeof( array ) / sizeof( *(array) ) )

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

Пример. Определение макроса max, принимающего два аргумента: a и b.

#define max( a, b ) ( (a) > (b) ? (a) : (b) )

Макрос вызывается так же, как и любая функция.

После замены макроса код будет выглядеть следующим образом:

z = ( (x) > (y) ? (x) : (y) );

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

Например, если f и g — две функции, вызов

не вычислит один раз f()и один раз g(), и поместит наибольшее значение в z, как этого можно было ожидать. Вместо этого одна из функций будет вычислена дважды. Если функция имеет побочные эффекты, то вероятно, что её поведение будет отличаться от ожидаемого.

Макросы Си могут походить на функции, создавая новый синтаксис в некоторых пределах, а также могут быть дополнены произвольным текстом (хотя компилятор Си требует, чтобы текст был без ошибок написанным Си-кодом или оформлен как комментарий), но у них есть некоторые ограничения как у программных конструкций. Макросы, схожие с функциями, например, могут быть вызваны как «настоящие» функции, но макрос не может быть передан другой функции при помощи указателя, по той причине, что макрос сам по себе не имеет адреса.

Некоторые современные языки обычно не используют такой способ метапрограммирования с использованием макросов как дополнений строк символов, в расчете или на автоматическое, или на ручное подключение функций и методов, а вместо этого — другие способы абстракции, такие как шаблоны, обобщённые функции или параметрический полиморфизм. В частности, встраиваемые функции^[en] позволяют избежать одного из главных недостатков макросов в современных версиях Си и C++, так как то, что встроенная функция обеспечивает преимущество макросов в снижении накладных расходов при вызове функции, но её адрес можно передавать в указателе для косвенных вызовов или использовать в качестве параметра. Аналогично, проблема множественных вычислений, упомянутая выше в макросе max, для встроенных функций неактуальна.

Константы #define можно заменить на enum, а макросы — на функции inline.

Операторы # и ##[править | править код]

Эти операторы используются при создании макросов. Оператор # обрамляет параметр макроса в двойные кавычки, например:

#define make_str( bar ) # bar
printf( make_str( 42 ) );

препроцессор преобразует в:

Оператор ## в макросах объединяет две лексемы, например:

#define MakePosition( x ) x##X, x##Y, x##Width, x##Height
int MakePosition( Object );

препроцессор преобразует в:

int ObjectX, ObjectY, ObjectWidth, ObjectHeight;

Формальное описание макроподстановок[править | править код]

1) Управляющая строка следующего вида заставляет препроцессор заменять идентификатор на последовательность лексем везде далее по тексту программы:

#define идентификатор последовательность_лексем

При этом символы пустого пространства в начале и в конце последовательности лексем выбрасываются.
Повторная строка #define с тем же идентификатором считается ошибкой,
если последовательности лексем не идентичны (несовпадения в символах пустого пространства не играют роли).

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

#define идентификатор( список_идентификаторов ) последовательность_лексем

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

Управляющая строка следующего вида приказывает препроцессору «забыть» определение, данное идентификатору:

Применение директивы #undef к не определенному ранее идентификатору не считается ошибкой.

{

• Если макроопределение было задано во второй форме, то любая следующая далее в тексте программы цепочка символов, состоящая из идентификатора макроса (возможно, с последующими символами пустого пространства), открывающей скобки, списка лексем, разделенных запятыми, и закрывающей скобки, представляет собой вызов макроса.
• Аргументами вызова макроса являются лексемы, разделенные запятыми, причем запятые, взятые в кавычки или вложенные круглые скобки, в разделении аргументов не участвуют.
• (!)Во время группировки аргументов раскрытие макросов в них не выполняется.
• Количество аргументов в вызове макроса должно соответствовать количеству параметров макроопределения.
• После выделения аргументов из текста символы пустого пространства, окружающие их, отбрасываются.
• Затем в замещающей последовательности лексем макроса каждый идентификатор-параметр, не взятый в кавычки, заменяется на соответствующий ему фактический аргумент из текста.
• (!)Если в замещающей последовательности перед параметром не стоит знак #, если и ни перед ним, ни после него нет знака ##, то лексемы аргумента проверяются на наличие в них макровызовов; если таковые есть, то до подстановки аргумента в нём выполняется раскрытие соответствующих макросов.

На процесс подстановки влияют два специальных знака операций.

• Во-первых, если перед параметром в замещающей строке лексем вплотную стоит знак #, то вокруг соответствующего аргумента ставятся строковые кавычки («), а потом идентификатор параметра вместе со знаком # заменяется получившимся строковым литералом.
  • Перед каждым символом » или , встречающимся вокруг или внутри строковой или символьной константы, автоматически вставляется обратная косая черта.
• Во-вторых, если последовательность лексем в макроопределении любого вида содержит знак ##, то сразу после подстановки параметров он вместе с окружающими его символами пустого пространства отбрасывается, благодаря чему сцепляются соседние лексемы, образуя тем самым новую лексему.
  • Результат не определён при генерировании таким образом недопустимых лексем языка или в случае, когда получающийся текст зависит от порядка применения операции ##.
  • Кроме того, знак ## не может стоять ни в начале, ни в конце замещающей последовательности лексем.

}

• (!)В макросах обоих видов замещающая последовательность лексем повторно просматривается в поиске новых define-идентификаторов.
• (!)Однако если какой-либо идентификатор уже был заменен в текущем процессе раскрытия, повторное появление такого идентификатора не вызовет его замены; он останется нетронутым.
• (!)Даже если развернутая строка макровызова начинается со знака #, она не будет воспринята как директива препроцессора.

Восклицательным знаком (!) отмечены правила, отвечающие за рекурсивные вызов и определения.

Пример раскрытия макроопределения[править | править код]

#define cat( x, y )  х ## у

Вызов макроса «cat(var, 123)» будет заменён на «var123».
Однако вызов «cat(cat(1, 2), 3)» не даст желаемого результата. Рассмотрим шаги работы препроцессора:

0: cat( cat( 1, 2 ), 3 )
1: cat( 1, 2 ) ## 3
2: cat( 1, 2 )3

Операция «##» помешала правильному раскрытию аргументов второго вызова «cat».
В результате получилась следующая цепочка лексем:

где «)3» — результат сцепления последней лексемы первого аргумента с первой лексемой второго аргумента, не является допустимой лексемой.

Можно задать второй уровень макроопределения в таком виде:

#define xcat( x, y ) cat( x, y )

Вызов «xcat(xcat(1, 2), 3)» будет заменён на «123». Рассмотрим шаги работы препроцессора:

0: xcat( xcat( 1, 2 ), 3 )
1: сat( xcat( 1, 2 ), 3 )
2: cat( cat( 1, 2 ), 3 )
3: cat( 1 ## 2, 3 )
4: cat( 12, 3 )
5: 12 ## 3
6: 123

Всё прошло благополучно, потому что в раскрытии макроса «xcat» не участвовал оператор «##».

Многие статические анализаторы не умеют правильно обрабатывать макросы, поэтому качество статического анализа снижается^{[источник не указан 2619 дней]}.

Предопределённые константы #define[править | править код]

Константы, создаваемые препроцессором автоматически:

• __LINE__ заменяется на номер текущей строки; номер текущей строки может быть переопределен директивой #line; используется для отладки;
• __FILE__ заменяется на имя файла; имя файла тоже может быть переопределено с помощью директивы #line;
• __FUNCTION__ заменяется на имя текущей функции;
• __DATE__ заменяется на текущую дату (на момент обработки кода препроцессором);
• __TIME__ заменяется на текущее время (на момент обработки кода препроцессором);
• __TIMESTAMP__ заменяется на текущие дату и время (на момент обработки кода препроцессором);
• __COUNTER__ заменяется на уникальное число, начиная от 0; после каждой замены число увеличивается на единицу;
• __STDC__ заменяется на 1, если компиляция происходит в соответствии со стандартом языка C;
• __STDC_HOSTED__ определена в C99 и выше; заменяется на 1, если выполнение происходит под управлением ОС;
• __STDC_VERSION__ определена в C99 и выше; для C99 заменяется на число 199901, а для C11 — на число 201112;
• __STDC_IEC_559__ определена в C99 и выше; константа существует, если компилятор поддерживает операции с числами с плавающей точкой по стандарту IEC 60559;
• __STDC_IEC_559_COMPLEX__ определена в C99 и выше; константа существует, если компилятор поддерживает операции с комплексными числами по стандарту IEC 60559; стандарт C99 обязывает поддерживать операции с комплексными числами;
• __STDC_NO_COMPLEX__ определена в C11; заменяется на 1, если не поддерживаются операции с комплексными числами;
• __STDC_NO_VLA__ определена в C11; заменяется на 1, если не поддерживаются массивы переменной длины; в С99 массивы переменной длины обязательно должны поддерживаться;
• __VA_ARGS__ определена в C99 и позволяет создавать макросы с переменным числом аргументов.

Условная компиляция[править | править код]

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

В общем случае, программисту необходимо использовать конструкцию типа:

# ifndef FOO_H
# define FOO_H
...(код заголовочного файла)...
# endif

Такая «защита макросов» предотвращает двойное подключение заголовочного файла путём проверки существования этого макроса, который имеет то же самое имя, что и заголовочный файл. Определение макроса FOO_H происходит, когда заголовочный файл впервые обрабатывается препроцессором. Затем, если этот заголовочный файл вновь подключается, FOO_H уже определен, в результате чего препроцессор пропускает полностью текст этого заголовочного файла.

То же самое можно сделать, включив в заголовочный файл директиву:

Условия препроцессора можно задавать несколькими способами, например:

# ifdef x
...
# else
...
# endif

или

# if x
...
# else
...
# endif

Этот способ часто используется в системных заголовочных файлах для проверки различных возможностей, определение которых может меняться в зависимости от платформы; например, библиотека Glibc использует макросы с проверкой особенностей с целью проверить, что операционная система и оборудование их (макросы) корректно поддерживает при неизменности программного интерфейса.

Большинство современных языков программирования не использует такие возможности, больше полагаясь на традиционные операторы условия if...then...else..., оставляя компилятору задачу извлечения бесполезного кода из компилируемой программы.

Диграфы и триграфы[править | править код]

См. диграфы и триграфы в языках C/C++.

Препроцессор обрабатывает диграфы «%:» («#»), «%:%:» («##») и триграфы «??=» («#»), «??/» («»).

Препроцессор считает последовательность «%:%:» двумя токенами при обработке кода C и одним токеном при обработке кода C++.

См. также[править | править код]

• Макропроцессор m4
• X Macro^[en]

Примечания[править | править код]

Ссылки[править | править код]

• Документация к препроцессору GCC Архивная копия от 26 марта 2011 на Wayback Machine (англ.)

From Wikipedia, the free encyclopedia

Many programming languages and other computer files have a directive, often called include, import, or copy, that causes the contents of the specified file to be inserted into the original file. These included files are called header files or copybooks. They are often used to define the physical layout of program data, pieces of procedural code, and/or forward declarations while promoting encapsulation and the reuse of code or data.

[edit]

In computer programming, a header file is a file that allows programmers to separate certain elements of a program’s source code into reusable files. Header files commonly contain forward declarations of classes, subroutines, variables, and other identifiers. Programmers who wish to declare standardized identifiers in more than one source file can place such identifiers in a single header file, which other code can then include whenever the header contents are required. This is to keep the interface in the header separate from the implementation.
^[1]

The C standard library and the C++ standard library traditionally declare their standard functions in header files.

Some recently created compiled languages (such as Java and C#) do not use forward declarations; identifiers are recognized automatically from source files and read directly from dynamic library symbols. This means header files are not needed.

Purpose[edit]

The include directive allows libraries of code to be developed which help to:

• ensure that everyone uses the same version of a data layout definition or procedural code throughout a program,
• easily cross-reference where components are used in a system,
• easily change programs when needed (only one file must be edited), and
• save time by reusing data layouts.

Example[edit]

An example situation which benefits from the use of an include directive is when referring to functions in a different file. Suppose there is some C source file containing a function add, which is referred to in a second file by first declaring its external existence and type (with a function prototype) as follows:

int add(int, int);

int triple(int x)
{
    return add(x, add(x, x));
}

One drawback of this approach is that the function prototype must be present in all files that use the function. Another drawback is that if the return type or arguments of the function are changed, all of these prototypes would need to be updated. Putting the prototype in a single, separate file avoids these issues. Assuming the prototype is moved to the file add.h, the second source file can then become:

#include "add.h"

int triple(int x)
{
    return add(x, add(x,x));
}

Now, every time the code is compiled, the latest function prototypes in add.h will be included in the files using them, avoiding potential errors.

Language support[edit]

C/C++[edit]

In the C and C++ programming languages, the #include preprocessor directive causes the compiler to replace that line with the entire text of the contents of the named source file (if included in quotes: «») or named header (if included in angle brackets: <>);^[2] note that a header doesn’t need to be a source file.^[3] Inclusion continues recursively on these included contents, up to an implementation-defined nesting limit. Headers need not have names corresponding to files: in C++ standard headers are typically identified with words, like «vector», hence #include <vector>, while in C standard headers have identifiers in the form of filenames with a «.h» extension, as in #include <stdio.h>. A «source file» can be any file, with a name of any form, but is most commonly named with a «.h» extension and called a «header file» (sometimes «.hpp» or «.hh» to distinguish C++ headers), though files with .c, .cc, and .cpp extensions may also be included (particularly in the single compilation unit technique), and sometimes other extensions are used.

These two forms of #include directive can determine which header or source file to include in an implementation-defined way. In practice, what is usually done is that the angle-brackets form searches for source files in a standard system directory (or set of directories), and then searches for source files in local or project-specific paths (specified on the command line, in an environment variable, or in a Makefile or other build file), while the form with quotes does not search in a standard system directory, only searching in local or project-specific paths.^[4] In case there is no clash, the angle-brackets form can also be used to specify project-specific includes, but this is considered poor form. The fact that headers need not correspond to files is primarily an implementation technicality, and is used to omit the .h extension in including C++ standard headers; in common use, «header» means «header file».

For example:

#include <stdio.h>  // Include the contents of the standard header 'stdio.h' (probably a file 'stdio.h').
#include <vector>  // Include the contents of the standard header 'vector' (probably a file 'vector.h').
#include "user_defined.h"  // Include the contents of the file 'user_defined.h'.

In C and C++, problems may be faced if two (or more) include files contain the same third file. One solution is to avoid include files from including any other files, possibly requiring the programmer to manually add extra include directives to the original file. Another solution is to use include guards.^[5]

COBOL[edit]

COBOL (and also RPG IV) allows programmers to copy copybooks into the source of the program in a similar way to header files, but it also allows for the replacement of certain text in them with other text. The COBOL keyword for inclusion is COPY, and replacement is done using the REPLACING ... BY ... clause. An include directive has been present in COBOL since COBOL 60, but changed from the original INCLUDE^[6] to COPY by 1968.^[7]

Fortran[edit]

Fortran does not require header files per se. However, Fortran 90 and later have two related features: include statements and modules. The former can be used to share a common file containing procedure interfaces, much like a C header, although the specification of an interface is not required for all varieties of Fortran procedures. This approach is not commonly used; instead, procedures are generally grouped into modules that can then be referenced with a use statement within other regions of code. For modules, header-type interface information is automatically generated by the compiler and typically put into separate module files, although some compilers have placed this information directly into object files. The language specification itself does not mandate the creation of any extra files, even though module procedure interfaces are almost universally propagated in this manner.

Pascal[edit]

Most Pascal compilers support the $i or $include compiler directive, in which the $i or $include directive immediately follows the start of a comment block in the form of

• {$i filename.pas}
• (*$I filename.inc*)
• {$include filename.inc}
• (*INCLUDE filename.pas*)

Where the $i or $include directive is not case sensitive, and filename.pas or filename.inc is the name of the file to be included. (It has been common practice to name Pascal’s include files with the extension .inc, but this is not required.) Some compilers, to prevent unlimited recursion, limit invoking an include file to a certain number, prohibit invoking itself or any currently open file, or are limited to a maximum of one include file at a time, e.g. an include file cannot include itself or another file. However, the program that includes other files can include several, just one at a time.

PHP[edit]

In PHP, the include directive causes another PHP file to be included and evaluated.^[8] Similar commands are require, which upon failure to include will produce a fatal exception and halt the script,^[9] and include_once and require_once, which prevent a file from being included or required again if it has already been included or required, avoiding the C’s double inclusion problem.

Other languages[edit]

There are many forms of the include directive, such as:

• include ... (Fortran, MASM)
• <!--#include ... --> (HTML SSI)
• import ...; (Java)
• import ... from ... (JavaScript as in ECMAScript)
• var ... = require("...") (JavaScript with CommonJS)
• <%@ include ... %> (JSP)
• {$I ...} (UCSD Pascal, Turbo Pascal)
• %include ... (PL/I)
• import ... (Python)
• /COPY QCPYLESRC,QBC (RPG IV – first argument is the filename, second argument is the copybook)
• use ...; (Rust)
• using ...; (C#)
• local ... = require("...") (Lua)
• import ...; (D)

Modern languages (e.g. Haskell and Java) tend to avoid copybooks or includes, preferring modules and import/export systems for namespace control. Some of these languages (such as Java and C#) do not use forward declarations and, instead, identifiers are recognized automatically from source files and read directly from dynamic library symbols (typically referenced with import or using directives), meaning header files are not needed.

See also[edit]

• Application programming interface (API)
• Precompiled header
• Subroutine
• Modular programming
• #pragma once
• Header-only
• Unity build
• Transclusion
• File inclusion vulnerability
• One Definition Rule (ODR)
• Interface Definition Language (IDL)
• Class implementation file

References[edit]

External links[edit]

• Organizing Code Files (the potential pitfalls and guidelines for using header files in C++)
• C++ header file inclusion rules

Препроцессор — это специальная программа, являющаяся частью компилятора языка Си. Она предназначена для предварительной обработки текста программы. Препроцессор позволяет включать в текст программы файлы и вводить макроопределения.
Работа препроцессора осуществляется с помощью специальных директив (указаний). Они отмечаются знаком решетка #. По окончании строк, обозначающих директивы в языке Си, точку с запятой можно не ставить.

Основные директивы препроцессора

Директива #include

Директива #define позволяет вводить в текст программы константы и макроопределения.
Общая форма записи

Поля Идентификатор и Замена разделяются одним или несколькими пробелами.
Директива #define указывает компилятору, что нужно подставить строку, определенную аргументом Замена, вместо каждого аргумента Идентификатор в исходном файле. Идентификатор не заменяется, если он находится в комментарии, в строке или как часть более длинного идентификатора.

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

• U или u представляет целую константу в беззнаковой форме (unsigned);
• F (или f) позволяет описать вещественную константу типа float;
• L (или l) позволяет выделить целой константе 8 байт (long int);
• L (или l) позволяет описать вещественную константу типа long double

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

замещается версией аргумента замена, в которой вместо формальных аргументов подставлены фактические аргументы.

Пример на Си: Вычисление синуса угла

Результат выполнения

Результат выполнения:

По умолчанию текст макроопределения должен размещаться на одной строке. Если требуется перенести текст макроопределения на новую строку, то в конце текущей строки ставится символ «обратный слеш» — .

Кроме того, директива #define позволяет замещать часть идентификатора. Для указания замещаемой части используется ##.

Результат выполнения:

Условная компиляция

Пример

Результат выполнения

Назад: Язык Си

Includes other source file into current source file at the line immediately after the directive.

[edit] Syntax

1) Searches for a header identified uniquely by h-char-sequence and replaces the directive by the entire contents of the header.

2) Searches for a source file identified by q-char-sequence and replaces the directive by the entire contents of the source file. It may fallback to (1) and treat q-char-sequence as a header identifier.

3) If neither (1) nor (2) is matched, pp-tokens will undergo macro replacement. The directive after replacement will be tried to match with (1) or (2) again.

4) Checks whether a header or source file is available for inclusion.

5) If (4) is not matched, h-pp-tokens will undergo macro replacement. The directive after replacement will be tried to match with (4) again.

[edit] Explanation

1) Searches a sequence of implementation-defined places for a header identified uniquely by h-char-sequence, and causes the replacement of that directive by the entire contents of the header. How the places are specified or the header identified is implementation-defined.

2) Causes the replacement of that directive by the entire contents of the source file identified by q-char-sequence. The named source file is searched for in an implementation-defined
manner. If this search is not supported, or if the search fails, the directive is reprocessed as if it reads syntax (1) with the identical contained sequence (including > characters, if any) from the original directive.

3) The preprocessing tokens after include in the directive are processed just as in normal text (i.e., each identifier currently defined as a macro name is replaced by its replacement list of preprocessing tokens). If the directive resulting after all replacements does not match one of the two previous forms, the behavior is undefined. The method by which a sequence of preprocessing tokens between a < and a > preprocessing token pair or a pair of » characters is combined into
a single header name preprocessing token is implementation-defined.

4) The header or source file identified by h-char-sequence or q-char-sequence is searched for as if that preprocessing token sequence were the pp-tokens in syntax (3), except that no further macro expansion is performed. If such a directive would not satisfy the
syntactic requirements of an #include directive, the program is ill-formed. The __has_include expression evaluates to 1 if the search for the source file succeeds, and to ​0​ if the search fails.

5) This form is considered only if syntax (4) does not match, in which case the preprocessing tokens are processed just as in normal text.

__has_include can be expanded in the expression of
#if and
#elif. It is treated as a defined macro by
#ifdef,
#ifndef,
#elifdef,
#elifndef (since C++23) and defined but cannot be used anywhere else.

[edit] Notes

Typical implementations search only standard include directories for syntax (1). The standard C++ library and the standard C library are implicitly included in these standard include directories. The standard include directories usually can be controlled by the user through compiler options.

The intent of syntax (2) is to search for the files that are not controlled by the implementation. Typical implementations first search the directory where the current file resides then falls back to (1).

When a file is included, it is processed by translation phases 1-4, which may include, recursively, expansion of the nested #include directives, up to an implementation-defined nesting limit. To avoid repeated inclusion of the same file and endless recursion when a file includes itself, perhaps transitively, header guards are commonly used: the entire header is wrapped in

#ifndef FOO_H_INCLUDED /* any name uniquely mapped to file name */
#define FOO_H_INCLUDED
// contents of the file are here
#endif

Many compilers also implement the non-standard pragma #pragma once with similar effects: it disables processing of a file if the same file (where file identity is determined in OS-specific way) has already been included.

A sequence of characters that resembles an escape sequence in q-char-sequence or h-char-sequence might result in an error, be interpreted as the character corresponding to the escape sequence, or have a completely different meaning, depending on the implementation.

A __has_include result of 1 only means that a header or source file with the specified name exists. It does not mean that the header or source file, when included, would not cause an error or would contain anything useful. For example, on a C++ implementation that supports both C++14 and C++17 modes (and provides __has_include in its C++14 mode as a conforming extension), __has_include(<optional>) may be 1 in C++14 mode, but actually #include <optional> may cause an error.

[edit] Example

#if __has_include(<optional>)
#  include <optional>
#  define has_optional 1
   template<class T> using optional_t = std::optional<T>;
#elif __has_include(<experimental/optional>)
#  include <experimental/optional>
#  define has_optional -1
   template<class T> using optional_t = std::experimental::optional<T>;
#else
#  define has_optional 0
#  include <utility>
 
template<class V>
class optional_t
{
    V v_{}; bool has_{false};
public:
    optional_t() = default;
    optional_t(V&& v) : v_(v), has_{true} {}
    V value_or(V&& alt) const& { return has_ ? v_ : alt; }
    /*...*/
};
#endif
 
#include <iostream>
 
int main()
{
    if (has_optional > 0)
        std::cout << "<optional> is presentn";
    else if (has_optional < 0)
        std::cout << "<experimental/optional> is presentn";
    else
        std::cout << "<optional> is not presentn";
 
    optional_t<int> op;
    std::cout << "op = " << op.value_or(-1) << 'n';
    op = 42;
    std::cout << "op = " << op.value_or(-1) << 'n';
}

<optional> is present
op = -1
op = 42

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also