Меню

Препроцесорни директиви в C ++

preprocessor directives c

Опитайте Нашия Инструмент За Премахване На Проблемите

Подробен поглед върху директивите на препроцесора в C ++.

Препроцесорът е уникална характеристика на C ++. В C ++ имаме стъпки като компилация, свързване и изпълнение за типична програма. В действителност имаме много други функции в програма C ++, които трябва да бъдат обработени, преди да предадете програмата за компилация.

За тази цел се извършва специална стъпка, наречена предварителна обработка. Предварителната обработка се извършва преди процеса на компилация и специалните функции се обработват предварително. В резултат се получава разширена програма C ++ и след това се предава на компилатора.

=> Посетете тук, за да научите C ++ от нулата.

Препроцесорни директиви в C ++

Какво ще научите:

Общ преглед

Специалните характеристики за предварителна обработка се идентифицират с помощта на обект, наречен „Директива за препроцесор“. Тези директиви за препроцесор казват на компилатора, че определена информация в програмата C ++, маркирана с директиви за препроцесор, трябва да бъде предварително обработена преди компилацията.

Имайте предвид, че в C ++ всички директиви на препроцесора започват със символ „#“. В момента, в който препроцесорът (част от компилатора) срещне символа #, информацията след символа # се обработва предварително, преди да предаде програмата на компилатора.

За разлика от другите изрази на C ++, директивите за препроцесор не завършват с точка и запетая.

В този урок ще разгледаме различните директиви на препроцесора, поддържани от C ++.

Директиви за включване на файлове

#include

Директива за включване на файлове #include ни позволява да включим други файлове в нашата програма източник. Можем да включим всеки заглавен файл, който съдържа дефиниции на различни предварително дефинирани функции в нашата програма, използвайки тези функции. Можем да включим заглавни файлове в нашата програма, като използваме следния синтаксис.

#include

Пример: #include

Вече видяхме това в нашите програми за C ++. Заглавката iostream съдържа функциите, необходими за поточно въвеждане / извеждане на данни като cout, cin и др.

Тъй като нашите програми се разрастват или функционалността става сложна, може да искаме да разделим програмата си на различни файлове или да импортираме функционалност от другите файлове. В този случай използваме дефинирани от потребителя файлове. За да включим дефинирани от потребителя файлове в нашата програма, можем да използваме следния синтаксис на директивата #include.

#include “filename”

Пример: #include “vector_int.h”

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

Примерният код по-долу показва използването на директивата #include.

Въпроси за интервю за .net уеб услуги
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Изход:

Това е пример, демонстриращ директивата за включване #include.

Както е показано, използвахме директивата #include, за да включим функционалността на заглавката в нашата програма.

Директиви за макродефиниция

#define

Директивата #define се използва за дефиниране на символни константи или макроси в програма C ++.

Общата форма на директива #define е:

#define macro_name replacement code

Когато препроцесор срещне макроса в програмата, препроцесорът замества този макрос с кода, дефиниран с помощта на директивата #define, преди кодът да бъде предаден на компилатора.

Кодът по-долу Пример показва символна константа RADIUS, която е дефинирана с помощта на директивата #define и нейното използване в програмата.

#include #define RADIUS 5 using namespace std; int main() { cout<<'Area of a circle : '<<3.142 * RADIUS * RADIUS; }

Изход:

Площ на кръг: 78.55

Както е показано в програмата, можем да използваме символична константа RADIUS в нашия код и тя ще бъде заменена от стойността, дефинирана за нея, използвайки директивата #define.

най-добрият софтуер за създаване на диаграми

Можем да използваме директивата #define, за да определим правилен функционален код. Тези функции обикновено са малки функции.

Пример е показан по-долу.

#include #define REC_AREA(length, breadth) (length * breadth) using namespace std; int main() { int length = 20, breadth = 5, area; area = REC_AREA(length, breadth); cout << 'Area of a rectangle is: ' << area; return 0; }

Изход:

Площта на правоъгълник е: 100

Тук, използвайки директивата #define, дефинирахме функция REC_AREA, която взема два аргумента, т.е. дължина и ширина и изчислява площта на правоъгълник. В основната функция ние просто използваме този макрос и му предоставяме два аргумента, за да получим площта на правоъгълник.

#undef

Макросите в програма, дефинирана с директивата #define, продължават, докато не бъдат дефинирани с помощта на директивата #undef. След като програмата срещне #undef, последващото използване на макрос (недефиниран от #undef) ще даде грешка при компилацията.

В горната програма, ако просто дадем изявление #undef REC_AREA след декларациите за цяло число, тогава програмата ще даде грешка при компилацията.

Директиви за условно компилиране

Освен директивите, обяснени по-горе, C ++ предоставя и следните директиви, които могат да се използват за условно компилиране на код. Тези директиви могат да се използват в подобни редове на оператора if-else на C ++.

Например, можем да зададем DEBUG за програма ON или OFF с помощта на тези условни директиви.

Някои от директивите за условно компилиране, предоставени в C ++, включват:

  • # ако
  • #elif
  • #endif
  • #ifdef
  • #ifndef
  • #else

Програмата по-долу демонстрира използването на директиви за условно компилиране в програма C ++.

#include using namespace std; #define DEBUG #define MAX(a,b) (((a)>(b)) ? a : b) int main () { int i, j; i = 100; j = 50; #ifdef DEBUG cout <<'Trace: Start of main function' << endl; #endif cout <<'The maximum is ' << MAX(i, j) << endl; #undef MAX //cout <<'The maximum is ' << MAX(10,20) << endl; #ifdef DEBUG cout <<'Trace: End of main function' << endl; #endif return 0; }

Изход:

Trace: Начало на основната функция
Максимумът е 100
Trace: Край на основната функция

В горната програма използваме директивата #ifdef - #endif, за да дефинираме DEBUG за програмата. След това дефинирахме макро функцията MAX, използвайки директивата #undef. Директивата за условно компилиране конструира #ifdef - #endif проверява дали е зададена DEBUG и ако е зададена, тя отпечатва няколко съобщения в програмата.

Операторите # & ##

Операторите # и ## са два специални оператора, които съответно се използват за преобразуване на текстов маркер в низ, който да се покаже, и обединяват два маркера.

По-долу е даден пример, демонстриращ и двата тези оператора.

#include using namespace std; #define MKSTR( x ) #x #define concat(a, b) a ## b int main () { cout <<'MKSTR(Hello World) = '<< MKSTR(Hello World) << endl; int xy = 100; cout <<'concat(x,y) = '<

Изход:

MKSTR (Hello World) = Hello World
concat (x, y) = 100

В горната програма дефинираме MKSTR с аргумент x. Той има тяло #x. Когато отпечатваме този MKSTR, използвайки аргумента „Hello World”, виждаме, че поради #x аргументът се преобразува в низ и се показва на изхода.

След това дефинирахме функция concat с два аргумента a и b. В тялото посочваме ## b. Изразът a ## b е равен на ab. По този начин в основната функция, когато извикаме concat (x, y), тя всъщност изчислява на xy, което е равно на целочислената променлива, която дефинирахме.

Други директиви

# грешка

Общият синтаксис на директивата #error е:

програма за изтегляне на видеоклипове от всеки уебсайт
#error error_message

Когато компилаторът срещне директива #error, той показва съобщението error_message и компилацията спира. Аргументът error_message може да съдържа една или повече думи със или без кавички.

# линия

Това казва на компилатора да промени вътрешно съхранявания номер и име на файл на компилатора на дадения номер и име на файл.

# линия цифрова последователност („име на файл“)

Цифровата_последователност може да бъде цяла константа.

Пример:# линия 200 тест.в

В горния пример номерът на вътрешно съхранената линия е зададен на 200 и името на файла се променя на test.c.

# прагма

Предоставя на компилатора инструкции, дефинирани от изпълнението. Тези инструкции са специфични за компилатора и платформата. Ако инструкцията не съвпада, директивата се игнорира, без да генерира синтактична грешка.

Предварително дефинирани макроси

C ++ също така дефинира множество предварително дефинирани макроси, които могат да се използват от програмистите.

Някои от тези макроси са представени в таблици по-долу.

Предварително дефиниран макросОписание
__FILE__Текущото име на файла на програмата, която се компилира
__ДАТА__Дата на превод на изходния код в обектен код във формат месец / ден / година
__TIME__Час във формата час: минута: секунда, в която се съставя програмата
__LINE__Текущият номер на реда на програмата, която се компилира
__cplusplusЦелочислена константа, която е дефинирана за всяка версия на компилатора

Следващата програма демонстрира тези макроси в програма.

#include using namespace std; int main () { cout<<'__LINE__ :' << __LINE__ << endl; cout<<'__FILE__ :' << __FILE__ << endl; cout<<'__DATE__ :' << __DATE__ << endl; cout<<'__TIME__ :' << __TIME__ << endl; cout<<'__cplusplus:'<<__cplusplus<

Изход:

__LINE__: 5
__FILE__: prog.cpp
__ДАТА__: 15 април 2019 г.
__TIME__: 12: 09: 15
__cplusplus: 201402

Изходът на програмата по-горе е в съответствие с обяснението на предварително дефинираните макроси по-горе и е обяснителен.

Заключение

В този урок видяхме различни директиви за препроцесор, предоставени от C ++, заедно с техните примери. Препроцесорните директиви ни помагат да напишем по-ефективни програми и по-четливи програми до известна степен.

Директивите за условна компилация също ни позволяват да разклоняваме изхода на нашата програма по различни начини.

=> Потърсете тук цялата серия за обучение на C ++.

Препоръчително четене

^