Ang mga direktiba ng preprocessor sa C++ ay tinutukoy ng # (hash) simbolo sa simula ng pahayag. Kasama sa mga karaniwang preprocessor na direktiba sa C++ pagsasama ng file at mga macro kahulugan. Ang mga direktiba na ito ay karaniwang inilalagay sa labas ng main() function sa itaas ng C++ program. Sa panahon ng pre-processing, isang intermediate na file na may .i nabuo ang extension.
#define Directive sa C++
Sa C++, ang #define na direktiba ay isang preprocessor na direktiba na ginagamit upang tukuyin ang mga constant o macro. Binibigyang-daan ka nitong tukuyin ang mga simbolikong pangalan o halaga na pinapalitan sa buong code bago maganap ang aktwal na proseso ng compilation.
Narito ang ilan sa mga pangunahing highlight ng #define Pre-processor
- Sa C++, ang preprocessor directive na #define ay ginagamit upang tukuyin ang mga macro.
- Ang mga macro sa C++ ay pinangalanang mga constant o expression na idineklara gamit ang #define na direktiba.
- Ang #define na mga direktiba ay tinutukoy din bilang mga Macro na direktiba.
- Kapag ang isang #define na direktiba ay nakatagpo sa isang C++ na programa, ang tinukoy na pangalan ng macro ay papalitan ng isang pare-parehong halaga o expression sa panahon ng paunang yugto ng compilation.
Syntax ng #define Directive
Ang syntax para sa paggamit ng #define na direktiba ay ang mga sumusunod:
#define identifier value
Kung saan ang identifier ay ang pangalan ng constant o macro na tinutukoy, at ang value ay ang value na dapat itong palitan kapag na-compile ang code.
Halimbawa ng #define Directive
Ang sumusunod ay isang halimbawa na nagpapaliwanag kung paano magagamit ang #define na direktiba sa C++ code:
#include#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int pangunahing ( ) {
doble radius = 5.0 ;
doble lugar = PI * SQUARE ( radius ) ;
std :: cout << 'Lugar:' << lugar << std :: endl ;
bumalik 0 ;
}
Sa halimbawang ito, tinutukoy namin ang dalawang constants gamit ang #define directive: PI, na kumakatawan sa mathematical constant pi, at SQUARE, na isang macro na kinakalkula ang parisukat ng isang ibinigay na halaga. Pagkatapos ay ginagamit namin ang mga constant na ito sa aming code upang kalkulahin ang lugar ng isang bilog na may ibinigay na radius.
Pagkakaiba sa pagitan ng #define at const
Isang karaniwang tanong na lumalabas kapag tinatalakay ang #define na direktiba ay kung paano ito naiiba sa paggamit ng mga variable ng const sa C++. Habang binibigyang-daan ka ng parehong diskarte na tukuyin ang mga constant na magagamit sa kabuuan ng iyong code, may ilang pangunahing pagkakaiba sa pagitan ng mga ito.
Isang malaking pagkakaiba sa pagitan ng #define at const ay ang #define ay isang preprocessor na direktiba, habang ang const ay isang keyword na bahagi ng C++ na wika mismo. Nangangahulugan ito na ang mga constant na tinukoy gamit ang #define ay pinapalitan ng kanilang mga halaga bago i-compile ang code, habang ang mga const variable ay pinangangasiwaan ng mismong compiler.
Ang isa pang pangunahing pagkakaiba sa pagitan ng #define at const ay ang mga variable ng const ay may partikular na uri, habang ang mga constant na tinukoy gamit ang #define ay wala. Nangangahulugan ito na maaari mong gamitin ang mga variable ng const sa mga lugar kung saan kinakailangan ang isang partikular na uri, habang ang mga constant na tinukoy gamit ang #define ay maaaring hindi palaging gumagana sa mga sitwasyong iyon.
Konklusyon
Ang #define na direktiba ay isang preprocessor na direktiba na ginagamit upang tukuyin ang mga constant o macro. Nagbibigay-daan ito sa amin na tukuyin ang mga simbolikong pangalan o halaga na pinapalitan sa buong code bago maganap ang aktwal na proseso ng compilation. Magbasa nang higit pa sa #define na direktiba sa C++ sa artikulong ito.