Sinusuportahan ng C++ ang ilang unary operator, bawat isa ay nagsisilbi ng isang natatanging layunin sa pagmamanipula ng mga variable. Magsimula tayo sa mga increment at decrement operator na karaniwang ginagamit sa mga loop at iba't ibang algorithm.
Halimbawa 1: Mga Operator ng Increment (++) at Decrement (–).
Ang increment (++) at decrement (–) unary operator ay mga pangunahing tool sa C++ para sa pagbabago ng halaga ng isang variable sa pamamagitan ng pagtaas o pagbaba nito ng 1, ayon sa pagkakabanggit. Ang increment operator (++) ay nagdaragdag ng 1 sa value ng variable, habang ang decrement operator (–) ay nagbabawas ng 1. Ang mga operator na ito ay maaaring ilapat sa mga variable na integer, floating-point, at pointer, na nagbibigay ng flexibility sa kanilang paggamit.
Tuklasin natin ang mga operator na ito sa pamamagitan ng praktikal na halimbawa:
#include
gamit namespace std ;
int pangunahing ( )
{
int counter = 0 ;
// Increment operator
cout << 'Paunang halaga: ' << counter << endl ;
counter ++ ;
cout << 'Halaga pagkatapos ng pagtaas: ' << counter << endl ;
// Operator ng pagbabawas
counter -- ;
cout << 'Halaga pagkatapos ng pagbabawas: ' << counter << endl ;
bumalik 0 ;
}
Kasama sa simpleng C++ program na ito ang kinakailangang input/output stream library na may “#include
Pagkatapos ng operasyong ito, ang na-update na halaga ng 'counter' ay ipinapakita gamit ang isa pang 'cout' na pahayag. Kasunod nito, ginagamit namin ang decrement operator (counter—) para bawasan ang halaga ng “counter” ng 1. Ang resulta ay ipapakita sa console. Sa huli, ang programa ay nagtatapos sa 'return 0;' pahayag na nagsasaad ng matagumpay na pagpapatupad.
Ang output na imahe ay nagpapakita ng paunang halaga, ang halaga pagkatapos ng pagtaas, at ang pinababang halaga.
Halimbawa 2: Positibo (+) at Negatibo (-) Operator
Habang ang positibong unary operator ay bihirang ginagamit, ang negatibong operator ay mahalaga para sa pagbabago ng tanda ng isang variable.
#includeGamit namespace std ;
int pangunahing ( ) {
int positiveValue = 10 ;
int negativeValue = - positiveValue ;
cout << 'Positibong halaga: ' << positiveValue << endl ;
cout << 'Negatibong halaga: ' << negativeValue << endl ;
bumalik 0 ;
}
Nagsisimula kami ng dalawang integer na variable para sa halimbawang code na ito na 'positiveValue' at 'negativeValue'. Ang 'positiveValue' ay itinalaga na may halagang 10. Kasunod nito, ipinapahayag namin ang 'negativeValue' at itinalaga ito kasama ang negation ng 'positiveValue' gamit ang unary minus operator. Epektibong binabago ng operator na ito ang tanda ng orihinal na halaga. Pagkatapos ay ginagamit namin ang pahayag na 'cout' upang ipakita ang parehong positibo at negatibong output sa console. Sa wakas, ang programa ay nagbabalik ng 0 na nagpapahiwatig ng matagumpay na pagkumpleto ng pangunahing pag-andar.
Kapag naisakatuparan, ang program na ito ay naglalabas ng positibo at negatibong mga halaga.
Halimbawa 3: Lohikal HINDI (!) Operator
Ang unary operator sa C++, na tinutukoy ng '!' simbolo, ay kilala bilang logical NOT operator. Ito ay dinisenyo upang baligtarin ang katotohanan na halaga ng isang naibigay na expression. Gumagana ito sa isang solong operand na karaniwang isang lohikal na pagpapahayag o isang kundisyon. Ang lohikal na NOT operation ay nagbubunga ng 'true' na kinalabasan kapag ang operand ay 'false' at nagbubunga ng isang 'false' na kinalabasan kapag ang operand ay 'true'.
Narito ang isang simpleng halimbawa na nagpapakita ng paggamit ng lohikal na NOT operator:
#includegamit namespace std ;
int pangunahing ( ) {
bool ay totoo = totoo ;
bool ay Mali = mali ;
bool resultaHindiTotoo = ! ay totoo ;
bool resultaNotFalse = ! ay Mali ;
cout << 'Orihinal na Halaga: ' << ay totoo << ', Pagkatapos ng HINDI: ' << resultaHindiTotoo << endl ;
cout << 'Orihinal na Halaga: ' << ay Mali << ', Pagkatapos ng HINDI: ' << resultaNotFalse << endl ;
bumalik 0 ;
}
Sa halimbawang ito, ipinapahayag namin ang dalawang Boolean variable, 'isTrue' at 'isFalse'. Pagkatapos ay ilalapat namin ang lohikal na NOT operator sa bawat variable, na iniimbak ang mga resulta sa 'resultNotTrue' at 'resultNotFalse', ayon sa pagkakabanggit. Kasunod na ini-print ng programa ang mga orihinal na halaga at ang mga resulta ng lohikal na NOT operation para sa parehong mga variable.
Sa pag-execute ng program na ito, mapapansin namin na binabaligtad ng logical NOT operator ang truth value ng “isTrue” (sa una ay nakatakda sa true), na ginagawa itong mali. Katulad nito, binabaligtad nito ang halaga ng katotohanan ng 'isFalse' (orihinal na mali), na nagbubunga ng totoo.
Ang output ay malinaw na naglalarawan ng pagbabaligtad ng mga halaga ng katotohanan na nakamit ng lohikal na NOT operator.
Halimbawa 4: Bitwise NOT (~) Operator
Ang bitwise NOT operator (~) sa C++ ay isang unary operator na nagsasagawa ng bitwise negation ng bawat bit ng operand nito. Gumagana ito sa mga pangunahing uri ng data, partikular sa mga integral, tulad ng mga integer. Ang kinalabasan ay nakakamit sa pamamagitan ng pag-invert ng bawat indibidwal na bit sa operand, pag-convert ng 0s sa 1s at 1s sa 0s.
Upang ilarawan ang paggamit nito, isaalang-alang ang sumusunod na snippet ng code:
#includegamit namespace std ;
int pangunahing ( ) {
int orihinal na Halaga = 5 ;
int resultaBitwiseNot = ~orihinal na Halaga ;
cout << 'Orihinal na Halaga: ' << orihinal na Halaga << ', Pagkatapos ng Bitwise HINDI: ' << resultaBitwiseNot << endl ;
bumalik 0 ;
}
Sa halimbawang ito, ipinapahayag namin ang isang variable na integer na 'originalValue' na may halagang '5'. Susunod, ginagamit namin ang bitwise NOT operator (~) sa variable na ito. Ang resulta ng variable na ito ay naka-imbak sa 'resultBitwiseNot'. Ang programa ay pagkatapos ay i-print ang orihinal na halaga at ang resulta pagkatapos ng bitwise NOT na operasyon sa pamamagitan ng paggamit ng 'cout' na pahayag.
Kapag pinatakbo namin ang program na ito, makikita namin na ang bitwise NOT operator ay binabaligtad ang bawat bit ng binary na representasyon ng 'originalValue', na nagreresulta sa isang bagong halaga.
Halimbawa 5: Address at Indidirection Operator
Ang address-ng operator, na tinutukoy ng simbolo na '&', ay nagsisilbi sa layunin ng pagkuha ng lokasyon ng memorya ng isang variable. Nagbabalik ito ng pointer sa variable na nagbibigay-daan sa hindi direktang pag-access sa halaga nito. Nakukuha ng indidirection o dereference operator (*) ang halaga na nakaimbak sa lokasyon ng memorya na tinukoy ng isang pointer. Nagbibigay ito ng paraan upang gumana sa aktwal na data sa pamamagitan ng isang pointer nang hindi direkta.
Unawain natin ang konsepto gamit ang isang halimbawa:
#includegamit namespace std ;
int pangunahing ( ) {
int halaga = 99 ;
cout << 'Orihinal na Halaga: ' << halaga << endl ;
int * ptr = at halaga ;
cout << 'Memory Address: ' << ptr << endl ;
int retrievedValue = * ptr ;
cout << 'Nakuhang Halaga: ' << retrievedValue << endl ;
bumalik 0 ;
}
Ang code na ito ay nagpapakita ng paggamit ng address at indidirection operator. Una, ang isang integer variable na pinangalanang 'value' ay sinisimulan sa halagang 99. Ang orihinal na halaga ng 'value' ay ilalabas sa console. Kasunod nito, ang isang 'ptr' pointer variable ay idineklara, at ang address-ng operator (&) ay ginagamit upang italaga ang memory address ng 'value' sa 'ptr'. Pagkatapos ay ilalabas ng programa ang memory address na ito, na nagpapakita ng pangunahing operasyon ng 'address' operator.
Pagkatapos nito, ang isang bagong integer variable na 'retrievedValue' ay idineklara, at ang indirection operator (*) ay ginagamit upang makuha ang halaga na nakaimbak sa memory address na itinuro ng 'ptr'. Ang nakuhang halaga ay ilalabas sa console.
Konklusyon
Ang artikulong ito ay nagbigay ng komprehensibong paggalugad ng unary operator sa C++. Nagsimula kami sa pamamagitan ng pagkakategorya sa mga unary operator sa iba't ibang uri kabilang ang arithmetic, logical, bitwise, at ang mga nauugnay sa address at indirection. Ang mga totoong sitwasyon sa mundo ay ipinakita upang ipakita ang kapaki-pakinabang na aplikasyon ng mga operator na ito. Ang mga operator na ito ay gumaganap ng mahahalagang tungkulin sa C++ programming na nagpapahintulot sa mga developer na gumana nang mahusay sa mga pointer at pamahalaan ang memorya.