Команды и директивы c с нуля. Препроцессорные директивы

14.04.2019

Директивы препроцессора языка си

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

Определение	Назначение
	Определение макроса
	Отмена определения макроса
	Включение объекта-заголовка
	Компиляция, если выражение истинно
	Компиляция, если макрос определен
	Компиляция, если макрос не определен
	Компиляция, если выражение в ifложно
	Составная директива else/if
	Окончание группы компиляции по условию
	Замена новым именем строки или имени исходного файла
	Формирование ошибок трансляции
	Действие определяется реализацией
	Null- директива

Директива # define

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

# define ИМЯ_МАКРОСА последовательность_символов

Последовательность символов называют еще строкой замещения. Когда препроцессор находит в исходном файле имя_макроса (просто макрос), он заменяет его на последовательность_символов.

Можно отменить определение макроса директивой # undef:

# undef имя_макроса

Данная строка удаляет любую ранее введенную строку замещения. Определение макроса теряется и имя_макроса становится неопределенным.

К примеру, можно определить МАХ как величину 100:

Это значение будет подставляться каждый раз вместо макроса МАХ в исходном файле, Можно также использовать макрос вместо строковой константы:

#defineNAME“TurboC++”

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

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

Пример : #define MIN(a, b) ((9a)<(b)) ? (a) : (b)

printf(“Минимум из x и y “ % d, MIN(x ,y));

printf(“Минимум из a и b “ % d, MIN(n ,m));

Когда программа будет компилироваться, в выражение, определенное MIN(a,b) будут подставлены соответственноxиyилиmиn. Аргументыaиbзаключены в круглые скобки, так как вместо них может подставляться некоторое выражение, а не просто идентификатор.

Например, printf(“Минимум “ %d,MIN(x*x,x));

Директива # error

Имеет вид: # error сообщение_об_ошибке

Эта команда прекращает компиляцию программы и выдает сообщение об ошибке.

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

К данным директивам относятся: # if , # else , # elif , # endif .

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

Директива # else используется так же, как иelseв языке Си.

Пример: Использование условной компиляции.

# include

# define MAX 100

printf(“ MAX равно %d \n”, MAX);

Директива # elif используется для организации вложенной условной компиляции. Форма использования ее следующая:

#if<выражение>

последовательность операторов

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

последовательность операторов

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

последовательность операторов

…………………………………..

Другой метод условной компиляции состоит в использовании директив # ifdef и# ifndef . Основная форма использования этих директив следующая:

# ifdef ИМЯ_МАКРОСА

# endif

и соответственно

# ifndef ИМЯ_МАКРОСА

последовательность операторов

# endif

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

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

#include #include "my_file.h"

Если имя файла заключено в угловые скобки (<>), считается, что нам нужен некий стандартный заголовочный файл, и компилятор ищет этот файл в предопределенных местах. (Способ определения этих мест сильно различается для разных платформ и реализаций.) Двойные кавычки означают, что заголовочный файл - пользовательский, и его поиск начинается с того каталога, где находится исходный текст программы.
Заголовочный файл также может содержать директивы #include. Поэтому иногда трудно понять, какие же конкретно заголовочные файлы включены в данный исходный текст, и некоторые заголовочные файлы могут оказаться включенными несколько раз. Избежать этого позволяют условные директивы препроцессора . Рассмотрим пример:

#ifndef BOOKSTORE_H #define BOOKSTORE_H /* содержимое файла bookstore.h */ #endif

Условная директива #ifndef проверяет, не было ли значение BOOKSTORE_H определено ранее. (BOOKSTORE_H - это константа препроцессора; такие константы принято писать заглавными буквами.) Препроцессор обрабатывает следующие строки вплоть до директивы #endif. В противном случае он пропускает строки от #ifndef до # endif.
Директива

#define BOOKSTORE_H

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

Int main() { #ifdef DEBUG cout << "Начало выполнения main()\n"; #endif string word; vector text; while (cin >> word) { #ifdef DEBUG cout << "Прочитано слово: " << word << "\n"; #endif text.push_back(word); } // ... }

Если константа DEBUG не определена, результирующий текст программы будет выглядеть так:

Int main() { string word; vector text; while (cin >> word) { text.push_back(word); } // ... }

В противном случае мы получим:

Int main() { cout << "Начало выполнения main()\n"; string word; vector text; while (cin >> word) { cout << "Прочитано слово: " << word << "\n"; text.push_back(word); } // ... }

Константа препроцессора может быть определена в командной строке при вызове компилятора с помощью опции -D (в различных реализациях эта опция может называться по-разному). Для UNIX-систем вызов компилятора с определением препроцессорной константы DEBUG выглядит следующим образом:

$ CC -DDEBUG main.C

Есть константы, которые автоматически определяются компилятором. Например, мы можем узнать, компилируем ли мы С++ или С программу. Для С++ программы автоматически определяется константа __cplusplus (два подчеркивания). Для стандартного С определяется __STDC__. Естественно, обе константы не могут быть определены одновременно. Пример:

#idfef __cplusplus // компиляция С++ программы extern "C"; // extern "C" объясняется в главе 7 #endif int main(int,int);

Другими полезными предопределенными константами (в данном случае лучше сказать переменными) препроцессора являются __LINE__ и __FILE__. Переменная __LINE__ содержит номер текущей компилируемой строки, а __FILE__ - имя компилируемого файла. Вот пример их использования:

If (element_count == 0) cerr << "Ошибка. Файл: " << __FILE__ << " Строка: " << __LINE__ << "element_count не может быть 0";

Две константы __DATE__ и __TIME__ содержат дату и время компиляции.
Стандартная библиотека С предоставляет полезный макрос assert(), который проверяет некоторое условие и в случае, если оно не выполняется, выдает диагностическое сообщение и аварийно завершает программу. Мы будем часто пользоваться этим полезным макросом в последующих примерах программ. Для его применения следует включить в программу директиву

#include

assert.h - это заголовочный файл стандартной библиотеки С. Программа на C++ может ссылаться на заголовочный файл как по его имени, принятому в C, так и по имени, принятому в C++. В стандартной библиотеке С++ этот файл носит имя cassert. Имя заголовочного файла в библиотеке С++ отличается от имени соответствующего файла для С отсутствием расширения.h и подставленной спереди буквой c (выше уже упоминалось, что в заголовочных файлах для C++ расширения не употребляются, поскольку они могут зависеть от реализации).
Эффект от использования директивы препроцессора #include зависит от типа заголовочного файла. Инструкция

#include

включает в текст программы содержимое файла cassert. Но поскольку все имена, используемые в стандартной библиотеке С++, определены в пространстве std, имя assert() будет невидимо до тех пор, пока мы явно не сделаем его видимым с помощью следующей using-директивы:

Using namespace std;

Если же мы включаем в программу заголовочный файл для библиотеки С

#include

то надобность в using-директиве отпадает: имя assert() будет видно и так. (Пространства имен используются разработчиками библиотек для предотвращения засорения глобального пространства имен. В разделе 8.5 эта тема рассматривается более подробно.)

#include

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

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

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

Директива #define

Директива #define принимает две формы:

определение констант;
определение макросов.

Определение констант

#define nameToken value

При использовании имени константы — nameToken , оно будет заменено значением value , то есть, грубо говоря — это та же самая переменная, значение которой изменить нельзя. Смотрим пример использования константы:

#include #define TEXT "Марс" // определение константы int main() { std::cout << TEXT; return 0; }

Как видите, для доступа к значению константы, просто используем её имя.

Определение параметризованных макросов

#define nameMacros(arg1, arg2, ...) expression

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

#define MAX(num1, num2) ((num1) > (num2) ? (num1) : (num2))

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

Директива #undef

Директива #undef переопределяет константу или препроцессорный макрос, ранее определенный с помощью директивы #define .

#undef nameToken

Давайте посмотрим пример использования директивы #undef:

#define E 2.71828 // раннее определенный макрос int sumE = E + E; // обращение к макросу #undef E // теперь E - не макрос

Как правило, директива #undef используются для снятия, ранее определенной константы или макроса, в небольшой области программы. Это делается для того, чтобы для всей программы, макроc или константа оставались, а для некоторой области, эти же макрос или константа могут быть переопределены. Небезопасно было бы во всей программе переопределять константу, но в короткий области, это сравнительно безопасно. Директива #undef является единственным способом создания этой области, так как область действия макросов или констант действует от директивы #define до #undef .

Директива #if

#if value // код, который выполнится, в случае, если value - истина #elsif value1 // этот код выполнится, в случае, если value1 - истина #else // код, который выполнится в противном случае #endif

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

Обратите внимание, что в #if могут быть вложенные директивы #elsif и #else . Ниже показан пример кода для комментирования блоков кода, используя следующую конструкцию:

#if 0 // код, который необходимо закомментировать #endif

Если у вас в программе есть блоки кода, которые содержат многострочные комментарии и вам требуется обернуть полностью этот блок кода в комментарий — ничего не получится, если вы воспользуетесь /*многострочный комментарий*/ . Другое дело — конструкция директив #if #endif .

Директива #ifdef

#ifdef nameToken // код, который выполнится, если nameToken определен #else // код, который выполнится, если nameToken не определен #endif

Директива #ifdef проверяет, был ли ранее определен макрос или символическая константа как #define . Если — да, компилятор включает в программу код, который находится между директивами #ifdef и #else , если nameToken ранее определен не был, то выполняется код между #else и #endif , или, если нет директивы #else , компилятор сразу переходит к #endif . Например, макрос __cpp определен в C++, но не в Си. Вы можете использовать этот факт для смешивания C и C++ кода, используя директиву #ifdef:

#ifdef __cpp // C++ код #else // Си код #endif

Директива #ifndef

#ifndef nameToken // код, который выполнится, если nameToken не определен #else // код, который выполнится, если nameToken определен #endif

Директива #ifndef проверяет, был ли ранее определен макрос или символическая константа как #define . Если — да, компилятор включает в программу код, который находится между директивами #else и #endif , если nameToken ранее определен не был, то выполняется код между #ifndef и #else , или, если нет директивы #else , компилятор сразу переходит к #endif . Директива #ifndef может быть использована для подключения заголовочных файлов. если они не подключены, для этого использовать символическую константу, как индикатор подключенного к проекту функционала.

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

#ifndef PRODUCT_H #define PRODUCT_H class Product { // код класса... }; #endif PRODUCT_H

В этом случае используется пустая символьная константа PRODUCT_H , которая может быть определена в программе только вместе с классом Product . Поэтому, если мы обнаружим, что константа PRODUCT_H уже определена, значит класс тоже и тогда мы исключим повторное определение класса, которое может привести к ошибке переопределения.

Директива #error

#error "Этот код не должен компилироваться"

Директива #error позволяет отображать в списке ошибок компиляции сообщение, в случае возникновения соответствующей ошибки. Эту директиву наиболее полезно использовать в сочетании с директивами #if , #elsif , #else для проверки компиляции, если некоторое условие не верно. Например:

#ifndef __unix__ // __unix__ обычно поддерживается в юникс-системах #error "Поддерживается только в Unix" #endif

Препроцессорный макрос FILE

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

Int error (const char* adrFile, const std::string& erMessage) { cerr << "[" << adrFile << "]" << arMessage << endl; } #define LOG(erMessage) error(__FILE__, arMessage) // макрос LOG может быть использован для получения сообщений об ошибках, которые выводятся на стандартный поток ошибок

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

Препроцессорный макрос LINE

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

Int error (int nLine, const std::string& erMessage) { cerr << "[" << nLine << "]" << erMessage << endl; } #define LOG(erMessage) error(__LINE__, erMessage) // макрос LOG может быть использован для получения сообщений об ошибках, с указанием номеров строк, которые выводятся на стандартный поток ошибок

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

Препроцессорный макрос DATE

Макрос __DATE__ раскрывается в текущую дату (время компиляции) в виде [ммм дд гггг] (например, «Dec 7 2012″), как строка. __DATE__ может быть использован для предоставления информации о времени компиляции.

Cout << __DATE__ << endl;

Вы можете также использовать макрос __TIME__ , чтобы получить текущее время компиляции.

Препроцессорный макрос TIME

Макрос __TIME__ раскрывается в текущее время (время компиляции) в формате чч: мм:cc в 24-часовом формате (например, «22:29:12″). Макрос __TIME__ может быть использован для предоставления информации о времени в конкретный момент компиляции.

Cout << __TIME__ << endl;

Препроцессорный макрос TIMESTAMP

Макрос __TIMESTAMP__ раскрывается в текущее время (время компиляции) в формате Ddd Mmm Date hh::mm::ss yyyy, время в 24-часовом формате:

Ddd это сокращенно день недели,
ммм это сокращенно месяц,
Date — текущий день месяца (1-31),
гггг — это четыре цифры года.

Например, "Fri Dec 7 00:42:53 2012" . Макрос __TIMESTAMP__ может быть использован для получения информации о дате и времени компиляции.

Cout << __TIMESTAMP__ << endl;

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

Директива #pragma

#pragma compiler specific extension

Директива #pragma используется для доступа к специфическим расширениям компилятора. Совместное использование директивы #pragma c лексемой once просит компилятор включить файл заголовка только один раз, независимо от того, сколько раз она был импортирован:

#pragma once // заголовочный файл

В этом примере, директива #pragma once не позволяет включать файл в проект несколько раз, то есть предотвращает переопределение.

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

#pragma warning (disable: 4018)

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

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

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

#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 будет для вас не заменимым помощником. Задавайте свои вопросы на этом форуме, вам обязательно помогут в решении вашей проблемы.

Одной из самых распространенных ошибок программистов считают создания велосипедов, колеса, и т.д. С этим невероятно сложно не согласиться, потому что на практике так и есть, но как с этим бороться? Многие программисты скажут вам в один голос: учить STL - стандартную библиотеку, которая содержит наработки множества разработчиков языка программирования, а также неплохо может помочь при разработке новой программы. В данной статье мы подробно разберем, что же такое C #Include, как это работает и для чего создавалось. Статья рекомендуется не только начинающим пользователям операционной системы Windows, но и программистам первого-второго курса.

Что это такое?

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

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

Да, многие скажут, что там нет как на С++. Это так, но можно написать ОС и на функциях, чему доказательством являются Linux и ядро Windows. В данном языке программирования каждая библиотека подключается в начале файла, все благодаря метки препроцессора С #include. После ключевого слова с решеткой должно быть название файла следующим образом: <так, если файл в папке с компилятором> и “так, если он вне папки компилятора”. Пример правильного подключения: #include

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

Библиотеки Visual С Include

Итак. Мы уже разобрались, что такое Include, теперь можем с ним работать, однако вы еще ничего не знаете про IDE - интегрированную среду разработки. Среда разработки - это, по сути, умный блокнот, если слишком уж сократить. Вы пишете свой код, после чего хотите его откомпилировать. Если бы вы работали в Linux, то пришлось бы делать компиляцию через командную строку, подключая вручную или через make-файл все нестандартные библиотеки, но в IDE это все делается автоматически.

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

Одним из лучших IDE по праву считают Microsoft Visual Studio. Более того, в данной среде разработки даже немного видоизменился сам язык, поэтому в данном пункте мы разберем самые востребованные стандартные библиотеки Visual C.

Список библиотек:

Time.h - заголовочный файл для работы с временными интервалами.
Stdlib.h - заголовочный файл с подключенным классом стандартной библиотеки.
Stdio.h - стандартная библиотека ввода\ввыода.
Fsteam.h - библиотека для работы с файлами.

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

Список всех Include с пояснениями на С

Вы знаете, что такое классы? Если нет, то у вас появились вопросы, почему же библиотеки заканчиваются на «.h». Если быть кратким, то классы - это определенного рода кубики «Лего», которые можно вставить в программу. Чтоб это было легко - они и существуют. По правилу хорошего тона программирования, объявления их параметров надо заполнять в заголовочном файле, а само выполнение в отдельном с расширением «*. с» или «*. cpp».

Перед началом пояснения требуется разобраться в библиотеке С: Include - эта библиотека создана специально для операционной системы «Виндовс», внутри нее находятся все необходимые функции и классы для работы не только с графической составляющей системы, но и с параметрами, точными настройками, командной строкой и многим прочим. Если хотите писать программы под «Виндовс», то она должна быть первой в списке изучения.

Список STL:

Vector.h - работа с динамической памятью, называемой векторами.
Map.h - специальные словари.
Iostream - библиотека для работы с вводом и выводом в консоль.
Fout - работа с файлами. Аналогом является C Include .
Stdlib - является классом наследником от других STL.
Errno.h - заголовочный файл для выведения ошибок в консоль.
Ctype.h - заголовочный файл для работы с аски-кодом.

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

В С++

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

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

Что будет, если на компьютере нет STL?

В С и С++ существует динамическая и статическая компиляция. В зависимости от системы, под которую изготовляется продукт, также и вкладываются соответствующие библиотеки. Например, библиотеки Windows.h нет на Linux, а на Windows нет x11.lib (там у библиотек такое расширение - *.lib). Данный факт требуется учитывать, но благодаря умным IDE можно выбрать между динамической и статической сборкой. При динамической - от системы специфические библиотеки, а в статической проект занимает больше, но гарантированно идет в конкретной системе.

В заключение

Надеемся, что вам понравилось окунуться в столь удивительный и красочный мир программирования. Если вы никогда не писали собственную программу, то рекомендуем начать это делать прямо сейчас, ведь вкус победы над машиной слишком приятен. Также надеемся, что изучение c Include вам далось без особых осложнений. В любом случае, можете навестить MDSN и узнать еще больше.

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

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

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

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

#include

#include «header2.h»

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

#ifndef CUCUMBLER_H

#define CUCUMBLER_H

/* содержимое файла cucumbler.h */

Директива #ifndef выполняет проверку не была ли определена константа CUCUMBLER_H ранее, и если ответ отрицательный, то выполняется определение данной константы, и прочего кода, который следует до директивы #endif. Как не сложно догадаться директива #define определяет константу CUCUMBLER_H. В данном случае подобный кусок кода помогает избежать многократного включения одного и того же кода, так как после первого включения проинициализируется константа CUCUMBLER_H и последующие проверки #ifndef CUCUMBLER_H будут возвращать FALSE.

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

#include

#include

#include

using namespace std;

cout << "Начало функции main()\n";

vector text_array;

while (cin >> text)

cout << "Прочитан текст: " << text << "\n";

text_array.push_back(text);

Если константа IN_DEBUG не задана, то препроцессор сгенерирует следующий исходник:

#include

#include

#include

using namespace std;

vector text_array;

while (cin >> text)

text_array.push_back(text);

Но если определить IN_DEBUG, то текст программы кардинальным образом поменяется

#include

#include

#include

using namespace std;

cout << "Начало функции main()\n";

vector text_array;

while (cin >> text)

cout << "Прочитан текст: " << text << "\n";

text_array.push_back(text);

Задать препроцессорную константу можно прямо из консоли. Например для компилятора g++ применяется следующий формат