Директивы препроцессора и указания компилятору. Препроцессор языка си

Оператор # текстовую лексему в строку, заключенную в кавычку. Смотрим пример:

#include using namespace std; #define message(s) cout << "Сообщение: " #s << endl; int main() { message("GunGame"); return 0; }

Выполняется конкатенация строк и макрос message разворачивается в cout << "Сообщение: GunGamen"; . Обратите внимание на то, что операция # должна использоваться совместно с аргументами, так как # ссылается на аргумент.

Макро оператор ##

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

#define type ch##ar type a; // переменная a тип данных char, так как ch и ar склеились в char

Рассмотрим еще один пример использования оператора ## , в котором объединим две лексемы:

#define TOKENCONCAT(x,y) x##y

Когда в программе выполняется вызов этого макроса, две лексемы объединяются в одну. Операция ## обязательно должна иметь два операнда.

P.S.: Любая серьёзная программа должна иметь свою базу данных, обычно для управления БД используются следующие СУБД: MySQL, MsSQL, PostgreeSQL, Oracle и др. В установке sql server, форум на cyberforum.ru будет для вас не заменимым помощником. Задавайте свои вопросы на этом форуме, вам обязательно помогут в решении вашей проблемы.

Заключительная глава книги посвящена описанию препроцессора C++. Препроцессор C++ - это часть компилятора, которая подвергает вашу программу различным текстовым преобразованиям до реальной трансляции исходного кода в объектный. Программист может давать препроцессору команды, называемые директивами препроцессора (preprocessor directives), которые, не являясь формальной частью языка C++, способны расширить область действия его среды программирования.

Препроцессор C++ включает следующие директивы.

Как видите, все директивы препроцессора начинаются с символа "#" .Теперь рассмотрим каждую из них в отдельности.

На заметку. Препроцессор C++ - прямой потомок препроцессора С, и некоторые его средства оказались избыточными после введения в C++ новых элементов. Однако он попрежнему является важной частью С++-среды программирования.

Директива #define

Директива #define определяет имя макроса.

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

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

Обратите внимание на то, что здесь нет точки с запятой. Заданная последовательность_символов завершается только символом конца строки. Между элементамимакроимя (имя_макроса) ипоследовательность_символов может быть любое количество пробелов.

Итак, после включения этой директивы каждое вхождение текстового фрагмента, определенное как макроимя , заменяется заданным элементомпоследовательность_символов . Например, если вы хотите использовать словоUP в качестве значения1 и словоDOWN в качестве значения0 , объявите такие директивы#define .

Данные директивы вынудят компилятор подставлять 1 или0 каждый раз, когда в файле исходного кода встретится словоUP илиDOWN соответственно. Например, при выполнении инструкции:

cout << UP << " " << DOWN << " " << UP + UP;

На экран будет выведено следующее:

После определения имени макроса его можно использовать как часть определения других макроимен. Например, следующий код определяет имена ONE ,TWO иTHREE и соответствующие им значения.

#define TWO ONE+ONE

#define THREE ONE+TWO

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

Препроцессор заменит строкой "Введите имя файла" каждое вхождение идентификатораGETFILE . Для компилятора эта cout-инструкция

cout << GETFILE;

в действительности выглядит так.

cout << "Введите имя файла";

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

#define GETFILE "Введите имя файла"

cout << "GETFILE - это макроимя\n";

на экране будет отображена эта информация

GETFILE - это макроимя,

Введите имя файла - это макроимя

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

#define LONG_STRING "Это очень длинная последовательность,\

которая используется в качестве примера."

Среди С++-программистов принято использовать для макроимен прописные буквы. Это соглашение позволяет с первого взгляда понять, что здесь используется макроподстановка. Кроме того, лучше всего поместить все директивы#define в начало файла или включить в отдельный файл, чтобы не искать их потом по всей программе.

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

#define MAX_SIZE 100

float balance;

double index;

int num_emp;

Важно! Важно помнить, что в C++ предусмотрен еще один способ определения констант, который заключается в использовании спецификатора const. Однако многие программисты "пришли" в C++ из С-среды, где для этих целей обычно использовалась директива #define. Поэтому вам еще часто придется с ней сталкиваться в С++-коде.

Макроопределения, действующие как функции

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

/* Использование "функциональных" макроопределений. */

#include

using namespace std;

#define MIN(a, b) (((a)<(b)) ? a: b)

cout << "Минимум равен: " << MIN(x, у);

При компиляции этой программы выражение, определенное идентификатором MIN (а, b) , будет заменено, ноx иy будут рассматриваться как операнды. Это значит, что coutинструкция после компиляции будет выглядеть так.

cout << "Минимум равен: " << (((х)<(у)) ? х: у);

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

Макроопределения, действующие как функции, - это макроопределения, которые принимают аргументы.

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

// Эта программа дает неверный ответ.

#include

using namespace std;

#define EVEN(a) a%2==0 ? 1: 0

if(EVEN(9+1)) cout << "четное число";

else cout << "нечетное число ";

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

Напомню, что оператор "%" имеет более высокий приоритет, чем оператор"+" . Это значит, что сначала выполнится операция деления по модулю (% ) для числа1 , а затем ее результат будет сложен с числом9 , что (конечно же) не равно0 . Чтобы исправить ошибку, достаточно заключить в круглые скобки аргументa в макроопределенииEVEN , как показано в следующей (исправленной) версии той же программы.

// Эта программа работает корректно.

#include

using namespace std;

#define EVEN(a) (a)%2==0 ? 1: 0

if(EVEN(9+1)) cout << "четное число";

else cout << "нечетное число";

Теперь сумма 9+1 вычисляется до выполнения операции деления по модулю. В общем случае лучше всегда заключать параметры макроопределения в круглые скобки, чтобы избежать непредвиденных результатов, подобных описанному выше.

Использование макроопределений вместо настоящих функций имеет одно существенное достоинство: поскольку код макроопределения расширяется в строке, и нет никаких затрат системных ресурсов на вызов функции, скорость работы вашей программы будет выше по сравнению с применением обычной функции. Но повышение скорости является платой за увеличение размера программы (из-за дублирования кода функции).

Важно! Несмотря на то что макроопределения все еще встречаются в C++-коде, макросы, действующие подобно функциям, можно заменить спецификатором inline, который справляется с той же ролью лучше и безопаснее. (Вспомните: спецификатор inline обеспечивает вместо вызова функции расширение ее тела в строке.) Кроме того, inline-функции не требуют дополнительных круглых скобок, без которых не могут обойтись макроопределения. Однако макросы, действующие подобно функциям, все еще остаются частью С++-программ, поскольку многие С/С++-программисты продолжают использовать их по привычке.

Директива #еrror

Директива #error отображает сообщение об ошибке.

Директива #error дает указание компилятору остановить компиляцию. Она используется в основном для отладки. Общий формат ее записи таков.

#error сообщение

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

Директива #include

Директива #include включает заголовок или другой исходный файл.

Директива препроцессора #include обязывает компилятор включить либо стандартный заголовок, либо другой исходный файл, имя которого указано в директиве#include . Имя стандартных заголовков заключается в угловые скобки, как показано в примерах, приведенных в этой книге. Например, эта директива

#include

Включает стандартный заголовок для векторов.

При включении другого исходного файла его имя может быть указано в двойных кавычках или угловых скобках. Например, следующие две директивы обязывают C++ прочитать и скомпилировать файл с именем sample.h :

#include

#include "sample.h"

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

Если же имя файла заключено в кавычки, поиск файла выполняется, как правило, в

текущем каталоге (что также определено конкретной реализацией). Во многих случаях это означает поиск текущего рабочего каталога. Если заданный файл не найден, поиск повторяется с использованием первого способа (как если бы имя файла было заключено в угловые скобки). Чтобы ознакомиться с подробностями, связанными с различной обработкой директивы #include в случае использования угловых скобок и двойных кавычек, обратитесь к руководству пользователя, прилагаемому к вашему компилятору. Инструкции#include могут быть вложенными в другие включаемые файлы.

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

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

Директивы #if, #else, #elif и #endif

Директивы #if, #ifdef, #ifndef, #else, #elif и #endif - это директивы условной компиляции.

Главная идея состоит в том, что если выражение, стоящее после директивы #if оказывается истинным, то будет скомпилирован код, расположенный между нею и директивой#endif в противном случае данный код будет опущен. Директива#endif используется для обозначения конца блока#if .

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

#if константное_выражение

последовательность инструкций

Если константное_выражение является истинным, код, расположенный непосредственно за этой директивой, будет скомпилирован. Рассмотрим пример.

// Простой пример использования директивы #if.

#include

using namespace std;

cout << "Требуется дополнительная память\n";

При выполнении эта программа отобразит сообщение Требуется дополнительная память на экране, поскольку, как определено в программе, значение константыМАХ больше 10. Этот пример иллюстрирует важный момент: Выражение, которое стоит после директивы#if , вычисляется во время компиляции. Следовательно, оно должно содержать только идентификаторы, которые были предварительно определены, или константы. Использование же переменных здесь исключено.

Поведение директивы #else во многом подобно поведению инструкцииelse , которая является частью языка C++: она определяет альтернативу на случай невыполнения директивы#if . Чтобы показать, как работает директива#else , воспользуемся предыдущим примером, немного его расширив.

// Пример использования директив #if/#else.

#include

using namespace std;

cout << "Требуется дополнительная память.\n");

cout << "Достаточно имеющейся памяти.\n";

В этой программе для имени МАХ определено значение, которое меньше 10, поэтому#if - ветвь кода не скомпилируется, но зато скомпилируется альтернативная #else -ветвь. В результате отобразится сообщениеДостаточно имеющейся памяти. .

Обратите внимание на то, что директива #else используется для индикации одновременно как конца #if -блока, так и начала #еlse -блока. В этом есть логическая необходимость, поскольку только одна директива#endif может быть связана с директивой

#if.

Директива #elif эквивалентна связке инструкций else-if и используется для формирования многозвенной схемы if-else-if , представляющей несколько вариантов компиляции. После директивы#elif должно стоять константное выражение. Если это выражение истинно, следующий блок кода скомпилируется, и никакие другие#elif - выражения не будут тестироваться или компилироваться. В противном случае будет проверено следующее по очереди #elif -выражение. Вот как выглядит общий формат использования директивы#elif .

#if выражение

последовательность инструкций

#elif выражение 1

последовательность инструкций

#elif выражение 2

последовательность инструкций

#еlif выражение 3

последовательность инструкций

#elif выражение N

последовательность инструкций

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

#define COMPILED_BY JOHN

#if COMPILED_BY == JOHN

char who = "John";

#elif COMPILED_BY == BOB

char who = "Bob";

char who = "Tom";

Директивы #if и#elif могут быть вложенными. В этом случае директива#endif ,#else или#elif связывается с ближайшей директивой#if или#elif . Например, следующий фрагмент кода совершенно допустим.

#if COMPILED_BY == BOB

#if DEBUG == FULL

#elif DEBUG == PARTIAL

cout << "Боб должен скомпилировать код" << "для отладки вывода данных.\n";

Директивы #ifdef и #ifndef

Директивы #ifdef и#ifndef предлагают еще два варианта условной компиляции, которые

можно выразить как "если определено"и "если не определено"соответственно.

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

#ifdef макроимя

последовательность инструкций

Если макроимя предварительно определено с помощью какой-нибудь директивы#define , то

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

#ifndef макроимя

последовательность инструкций

Если макроимя не определено с помощью какой-нибудь директивы#define , топоследовательность инструкций , расположенная между директивами#ifdef и#endif , будет скомпилирована.

Как директива #ifdef , так и директива#ifndef может иметь директиву#else или#elif . Рассмотрим пример.

#include

using namespace std;

cout << "Программист Том.\n";

cout << "Программист неизвестен.\n";

cout << "Имя RALPH не определено.\n";

При выполнении эта программа отображает следующее.

Программист Том.

Имя RALPH не определено.

Но если бы идентификатор ТОМ был не определен, то результат выполнения этой программы выглядел бы так.

Программист неизвестен.

Имя RALPH не определено.

И еще. Директивы #ifdef и#ifndef можно вкладывать точно так же, как и директивы#if .

Директива #undef

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

#undef макроимя

Рассмотрим пример.

#define TIMEOUT 100

Здесь имена TIMEOUT иWAIT определены до тех пор, пока не выполнится директива

#undef.

Основное назначение директивы #undef - разрешить локализацию макроимен для тех частей кода, в которых они нужны.

Использование оператора defined

Помимо директивы #ifdef существует еще один способ выяснить, определено ли в программе некоторое макроимя. Для этого можно использовать директиву#if в сочетании с оператором времени компиляцииdefined . Например, чтобы узнать, определено ли макроимяMYFILE , можно использовать одну из следующих команд препроцессорной обработки.

#if defined MYFILE

При необходимости, чтобы реверсировать условие проверки, можно предварить оператор defined символом"!" . Например, следующий фрагмент кода скомпилируется только в том случае, если макроимяDEBUG не определено.

#if !defined DEBUG

cout << "Окончательная версия!\n";

О роли препроцессора

Препроцессор C++ - прямой потомок препроцессора языка С, причем без каких-либо усовершенствований. Однако его роль в C++ намного меньше роли, которую играет препроцессор в С. Дело в том, что многие задачи, выполняемые препроцессором в С, реализованы в C++ в виде элементов языка. Страуструп тем самым выразил свое намерение сделать функции препроцессора ненужными, чтобы в конце концов от него можно было бы совсем освободить язык.

На данном этапе препроцессор уже частично избыточен. Например, два наиболее употребительных свойства директивы #define были заменены инструкциями C++. В частности, ее способность создавать константное значение и определять макроопределение, действующее подобно функциям, сейчас совершенно избыточна. В C++ есть более эффективные средства для выполнения этих задач. Для создания константы достаточно определить const -переменную. А с созданием встраиваемой (подставляемой) функции вполне справляется спецификаторinline . Оба эти средства лучше работают, чем соответствующие механизмы директивы#define .

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

"превращения" кода в комментарий делает использование таких директив условной компиляции, как #ifdef , частично избыточным.

Директива #line

Директива #line изменяет содержимое псевдопеременных _ _LINE_ _ и _ _FILE_ _.

Директива #line используется для изменения содержимого псевдопеременных_ _LINE_ _ и_ _FILE_ _ , которые являются зарезервированными идентификаторами (макроименами). Псевдопеременная_ _LINE_ _ содержит номер скомпилированной строки, а псевдопеременная_ _FILE_ _ - имя компилируемого файла. Базовая форма записи этой команды имеет следующий вид.

#line номер "имя_файла"

Здесь номер - это любое положительное целое число, аимя_файла - любой допустимый идентификатор файла. Значение элементаномер становится номером текущей исходной строки, а значение элементаимя_файла - именем исходного файла.Имя_файла

Элемент необязательный. Директива #line используется, главным образом, в целях отладки и в специальных приложениях.

Например, следующая программа обязывает начинать счет строк с числа 200. Инструкция cout отображает номер 202, поскольку это - третья строка в программе после директивной инструкции #line 200 .

#include

using namespace std;

#line 200 // Устанавливаем счетчик строк равным 200.

int main() // Эта строка сейчас имеет номер 200.

{// Номер этой строки равен 201.

cout << _ _LINE_ _;// Здесь выводится номер 202.

Директива #pragma

Директива #pragma зависит от конкретной реализации компилятора.

Работа директивы #pragma зависит от конкретной реализации компилятора. Она позволяет выдавать компилятору различные инструкции, предусмотренные создателем компилятора. Общий формат его использования таков.

Здесь элемент имя представляет имя желаемой #pragma -инструкции. Если указанное

имя не распознается компилятором, директива #pragma попросту игнорируется без сообщения об ошибке.

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

Операторы препроцессора "#" и "##"

В C++ предусмотрена поддержка двух операторов препроцессора: "#" и"##" . Эти операторы используются совместно с директивой#define . Оператор"#" преобразует следующий за ним аргумент в строку, заключенную в кавычки. Рассмотрим, например, следующую программу.

#include

using namespace std;

#define mkstr(s) # s

cout << mkstr(Я в восторге от C++);

Препроцессор C++ преобразует строку

cout << mkstr(Я в восторге от C++);

cout << "Я в восторге от C++";

Оператор используется для конкатенации двух лексем. Рассмотрим пример.

#include

using namespace std;

#define concat(a, b) a ## b

cout << concat(x, y);

Препроцессор преобразует строку

cout << concat (x, y);

cout << xy;

Если эти операторы вам кажутся странными, помните, что они не являются операторами "повседневного спроса" и редко используются в программах. Их основное назначение - позволить препроцессору обрабатывать некоторые специальные ситуации.

Зарезервированные макроимена

В языке C++ определено шесть встроенных макроимен.

Рассмотрим каждое из них в отдельности.

Макросы _ _LINE_ _ и_ _FILE_ _ описаны при рассмотрении директивы#line выше в этой главе. Они содержат номер текущей строки и имя файла компилируемой программы.

Макрос _ _DATE_ _ представляет собой строку в форматемесяц/день/год , которая означает дату трансляции исходного файла в объектный код.

Время трансляции исходного файла в объектный код содержится в виде строки в макросе _ _TIME_ _ . Формат этой строки следующий:часы.минуты.секунды .

Точное назначение макроса _ _STDC_ _ зависит от конкретной реализации компилятора. Как правило, если макрос_ _STDC_ _ определен, то компилятор примет только стандартный С/С++-код, который не содержит никаких нестандартных расширений.

Компилятор, соответствующий ANSI/ISO-стандарту C++, определяет макрос_ _cplusplus как значение, содержащее по крайней мере шесть цифр. "Нестандартные" компиляторы должны использовать значение, содержащее пять (или даже меньше) цифр.

Мысли "под занавес"

Мы преодолели немалый путь: длиной в целую книгу. Если вы внимательно изучили все приведенные здесь примеры, то можете смело назвать себя программистом на C++. Подобно многим другим наукам, программирование лучше всего осваивать на практике, поэтому теперь вам нужно писать побольше программ. Полезно также разобраться в С++- программах, написанных другими (причем разными) профессиональными программистами. При этом важно обращать внимание на то, как программа оформлена и реализована. Постарайтесь найти в них как достоинства, так и недостатки. Это расширит диапазон ваших представлений о программировании. Подумайте также над тем, как можно улучшить существующий код, применив контейнеры и алгоритмы библиотеки STL. Эти средства, как правило, позволяют улучшить читабельность и поддержку больших программ. Наконец, просто больше экспериментируйте! Дайте волю своей фантазии и вскоре вы почувствуете себя настоящим С++-программистом!

Для продолжения теоретического освоения C++ предлагаю обратиться к моей книге Полный справочник по C++ , М. : Издательский дом "Вильямс". Она содержит подробное описание элементов языка C++ и библиотек.

Последнее обновление: 22.05.2017

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

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

Мы можем использовать следующие директивы:

#define : определяет макрос или препроцессорный идентификатор

#undef : отменяет определение макроса или идентификатора

#ifdef : проверяет, определен ли идентификатор

#ifndef : проверяет неопределенности идентификатор

#include : включает текст из файла

#if : проверяет условие выражение (как условная конструкция if)

#else : задает альтернативное условие для #if

#endif : окончание условной директивы #if

#elif : задает альтернативное условие для #if

#line : меняет номер следующей ниже строки

#error : формирует текст сообщения об ошибке трансляции

#pragma : определяет действия, которые зависят от конкретной реализации компилятора

# : пустая директива, по сути ничего не делает

Рассмотрим основные из этих директив.

Директива #include. Включение файлов

Ранее уже использовалась директива #include . Эта директива подключает в исходный текст файлы. Она имеет следующие формы применения:

#include <имя_файла> // имя файла в угловых скобках #include "имя_файла" // имя файла в кавычках

Например, если нам надо задействовать в приложении консольный ввод-вывод с помощью функций printf() или scanf() , то нам надо подключить файл "stdio.h", который содержит определение этих функций:

#include

При выполнении этой директивы препроцессор вставляет текст файла stdio.h. Данный файл еще называется заголовочным. Заголовочные файлы содержат прототипы функций, определения и описания типов и констант и имеют расширение .h .

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

assert.h : отвечает за диагностику программ

complex.h : для работы с комплексными числами

ctype.h : отвечает за преобразование и проверку символов

errno.h : отвечает за проверку ошибок

fenv.h : для доступа к окружению, которое управляет операциями с числами с плавающей точкой

float.h : отвечает за работу с числами с плавающей точкой

inttypes.h : для работы с большими целыми числами

iso646.h : содержит ряд определений, которые расширяют ряд логических операций

limits.h : содержит предельные значения целочисленных типов

locale.h : отвечает за работу с локальной культурой

math.h : для работы с математическими выражениями

setjmp.h : определяет возможности нелокальных переходов

signal.h : для обработки исключительных ситуаций

stdalign.h : для выравнивания типов

stdarg.h : обеспечивает поддержку переменного числа параметров

stdatomic.h : для выполнения атомарных операций по разделяемым данным между потоками

stdbool.h : для работы с типом _Bool

stddef.h : содержит ряд вспомогательных определений

stdint.h : для работы с целыми числами

stdio.h : для работы со средствами ввода-вывода

stdlib.h : содержит определения и прототипы функций общего пользования

stdnoreturn.h : содержит макрос noreturn

string.h : для работы со строками

tgmath.h : подключает math.h и complex.h плюс добавляет дополнительные возможности по работе с математическими вычислениями

threads.h : для работы с потоками

time.h : для работы с датами и временем

uchar.h : для работы с символами в кодировке Unicode

wchar.h : для работы с символами

wctype.h : содержит дополнительные возможности для работы с символами

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

Кроме стандартных заголовочных файлов мы можем подключать и свои файлы. Например, в той же папке, где находиться главный файл программы, определим еще один файл, который назовем main.c . Определим в нем следующий код:

Int number = 5;

Здесь просто определена одна переменная. Теперь подключим этот файл в программу:

#include #include "main.c" int main(void) { printf("%d", number); // 5 return 0; }

При подключении своих файлов их имя указывается в кавычках. И несмотря на то, что в программе не определена переменная number, она будет браться из подключенного файла main.c. Но опять же отмечу, важно, что в данном случае файл main.c располагается в одной папке с главным файлов программы.

В то же время данный способ прекрасно работает в GCC. Но для разных сред программирования способ подключения файлов может отличаться. Например, в Visual Studio мы получим ошибку. И более правильный подход будет состоять в том, что определить объявление объекта (переменной/константы) или функции в дополнительном заголовочном файле, а определение объекта или функции поместить в стандартный файл с расширением .c .

Например, в нашем в файле main.c уже есть определение переменной number. Теперь в ту же папку добавим новый файл main.h - файл с тем же названием, но другим расширением. И определим в main.h следующий код:

Extern int number;

Ключевое слово extern указывает, что данный объект является внешним. И в этом случае мы могули бы его подключить в файл исходного кода:

#include #include "main.h" // объявление или описание объекта #include "main.c" // определение объекта int main(void) { printf("%d", number); return 0; }

Этот пример также будет работать в GCC, однако как уже было рассмотрено выше, подключение файла main.h для GCC необязательно.

Если разработка ведется в Visual Studio , то определение объекта не надо подключать исходный файл:

#include #include "main.h" // объявление или описание объекта int main(void) { printf("%d", number); return 0; }

Несмотря на то, что здесь явным образом не подключается файл main.c, но при трансляции Visual Studio через заголовочный файл main.h сможет подключить находящийся в той же папке файл main.c.