C++ atbalsta vairākus unārus operatorus, no kuriem katrs kalpo unikālam mērķim, manipulējot ar mainīgajiem. Sāksim ar palielināšanas un samazināšanas operatoriem, kurus parasti izmanto cilpās un dažādos algoritmos.
1. piemērs: palielināšanas (++) un samazināšanas (–) operatori
Unārie operatori pieauguma (++) un samazinājuma (–) ir galvenie rīki C++, lai mainītu mainīgā lieluma vērtību, attiecīgi palielinot vai samazinot to par 1. Palielināšanas operators (++) pievieno 1 mainīgā vērtībai, bet samazināšanas operators (–) atņem 1. Šos operatorus var lietot veseliem skaitļiem, peldošā komata un rādītāja mainīgajiem, nodrošinot elastību to lietošanā.
Izpētīsim šos operatorus, izmantojot praktisku piemēru:
#include
izmantojot nosaukumvieta std ;
starpt galvenais ( )
{
starpt skaitītājs = 0 ;
// Palielināšanas operators
cout << 'Sākotnējā vērtība:' << skaitītājs << endl ;
skaitītājs ++ ;
cout << 'Vērtība pēc pieauguma:' << skaitītājs << endl ;
// Samazināt operatoru
skaitītājs -- ;
cout << 'Vērtība pēc samazinājuma:' << skaitītājs << endl ;
atgriezties 0 ;
}
Šajā vienkāršajā C++ programmā ir iekļauta nepieciešamā ievades/izvades straumes bibliotēka ar “#include
Pēc šīs darbības atjauninātā “skaitītāja” vērtība tiek parādīta, izmantojot citu “cout” paziņojumu. Pēc tam mēs izmantojam samazināšanas operatoru (skaitītājs-), lai samazinātu “skaitītāja” vērtību par 1. Pēc tam rezultāts tiek parādīts konsolē. Galu galā programma beidzas ar “atgriešanās 0;” paziņojums, kas norāda uz veiksmīgu izpildi.
Izvades attēlā tiek parādīta sākotnējā vērtība, vērtība pēc pieauguma un samazinātā vērtība.
2. piemērs: pozitīvi (+) un negatīvie (-) operatori
Lai gan pozitīvs unārais operators tiek izmantots reti, negatīvais operators ir būtisks mainīgā lieluma zīmes maiņai.
#includeIzmantojot nosaukumvieta std ;
starpt galvenais ( ) {
starpt pozitīvaVērtība = 10 ;
starpt negatīvāVērtība = - pozitīvaVērtība ;
cout << 'Pozitīvā vērtība:' << pozitīvaVērtība << endl ;
cout << 'Negatīvā vērtība:' << negatīvāVērtība << endl ;
atgriezties 0 ;
}
Mēs inicializējam divus veselu skaitļu mainīgos lielumus šim parauga kodam, kas ir “positiveValue” un “negativeValue”. “PositiveValue” tiek piešķirta ar vērtību 10. Pēc tam mēs deklarējam “negativeValue” un piešķiram to ar “pozitīvāVērtības” noliegumu, izmantojot operatoru unārā mīnus. Šis operators efektīvi maina sākotnējās vērtības zīmi. Pēc tam mēs izmantojam paziņojumu “cout”, lai konsolē parādītu gan pozitīvo, gan negatīvo izvadi. Visbeidzot, programma atgriež 0, kas norāda uz veiksmīgu galvenās funkcijas izpildi.
Kad šī programma tiek izpildīta, tā izvada pozitīvās un negatīvās vērtības.
3. piemērs: loģisks NAV (!) operators
Unārais operators valodā C++, kas apzīmēts ar “!” simbols ir pazīstams kā loģiskais NOT operators. Tas ir paredzēts, lai apgrieztu dotās izteiksmes patiesības vērtību. Tas darbojas ar vienu operandu, kas parasti ir loģiska izteiksme vai nosacījums. Loģiskā darbība NOT dod “patiesu” rezultātu, ja operands ir “nepatiess”, un dod “nepatiesu” rezultātu, ja operands ir “patiess”.
Šeit ir vienkāršs piemērs, kas parāda loģiskā operatora NOT izmantošanu:
#includeizmantojot nosaukumvieta std ;
starpt galvenais ( ) {
bool ir patiess = taisnība ;
bool ir False = viltus ;
bool rezultātsNepatiess = ! ir patiess ;
bool rezultātsNavFalse = ! ir False ;
cout << 'Sākotnējā vērtība:' << ir patiess << ', Pēc NOT: ' << rezultātsNepatiess << endl ;
cout << 'Sākotnējā vērtība:' << ir False << ', Pēc NOT: ' << rezultātsNavFalse << endl ;
atgriezties 0 ;
}
Šajā piemērā mēs deklarējam divus Būla mainīgos, “isTrue” un “isFalse”. Pēc tam katram mainīgajam piemērojam loģisko operatoru NOT, saglabājot rezultātus attiecīgi “resultNotTrue” un “resultNotFalse”. Pēc tam programma izdrukā abu mainīgo sākotnējās vērtības un loģiskās darbības NOT rezultātus.
Palaižot šo programmu, mēs pamanīsim, ka loģiskais operators NOT apvērš patiesības vērtību “isTrue” (sākotnēji iestatīta uz True), padarot to nepatiesu. Tāpat tas apvērš patiesības vērtību “isFalse” (sākotnēji false), iegūstot patiesu.
Izvade skaidri ilustrē patiesības vērtību inversiju, ko panāk loģiskais operators NOT.
4. piemērs: Bitwise NOT (~) operators
Bitu NOT operators (~) C++ ir unārs operators, kas veic katra sava operanda bita bitu noliegšanu. Tas darbojas ar pamatdatu tipiem, īpaši integrālajiem, piemēram, veseliem skaitļiem. Rezultāts tiek sasniegts, apgriežot katru atsevišķo bitu operandā, pārvēršot 0s uz 1s un 1s par 0s.
Lai ilustrētu tā lietojumu, apsveriet šādu koda fragmentu:
#includeizmantojot nosaukumvieta std ;
starpt galvenais ( ) {
starpt sākotnējāVērtība = 5 ;
starpt rezultātsBitiskiNav = ~originalValue ;
cout << 'Sākotnējā vērtība:' << sākotnējāVērtība << ', Pēc Bitwise NAV: ' << rezultātsBitiskiNav << endl ;
atgriezties 0 ;
}
Šajā piemērā mēs deklarējam “originalValue” veselu mainīgo ar vērtību “5”. Tālāk šim mainīgajam mēs izmantojam operatoru bitiem NOT (~). Šī mainīgā rezultāts tiek saglabāts mapē “resultBitwiseNot”. Pēc tam programma izdrukā sākotnējo vērtību un rezultātu pēc operācijas bitu virzienā NOT, izmantojot paziņojumu “cout”.
Palaižot šo programmu, mēs redzēsim, ka bitu virzienā NOT operators apgriež katru “originalValue” binārā attēlojuma bitu, kā rezultātā tiek iegūta jauna vērtība.
5. piemērs: Adrešu un norādes operatori
Operatora adrese, kas apzīmēta ar simbolu “&”, kalpo mainīgā lieluma atmiņas vietas izgūšanai. Tas atgriež rādītāju uz mainīgo, kas nodrošina netiešu piekļuvi tā vērtībai. Netiešās vai atsauces atcelšanas operators (*) iegūst vērtību, kas tiek saglabāta ar rādītāju norādītajā atmiņas vietā. Tas nodrošina veidu, kā netieši strādāt ar faktiskajiem datiem, izmantojot rādītāju.
Izpratīsim jēdzienu ar piemēru:
#includeizmantojot nosaukumvieta std ;
starpt galvenais ( ) {
starpt vērtību = 99 ;
cout << 'Sākotnējā vērtība:' << vērtību << endl ;
starpt * ptr = & vērtību ;
cout << 'Atmiņas adrese:' << ptr << endl ;
starpt RetrievedValue = * ptr ;
cout << 'Izgūtā vērtība:' << RetrievedValue << endl ;
atgriezties 0 ;
}
Šis kods ilustrē adrešu un netiešo operatoru izmantošanu. Pirmkārt, vesela skaitļa mainīgais ar nosaukumu “value” tiek inicializēts ar vērtību 99. Pēc tam konsole tiek izvadīta sākotnējā “value” vērtība. Pēc tam tiek deklarēts rādītāja mainīgais “ptr”, un operatora adrese (&) tiek izmantota, lai “vērtības” atmiņas adresi piešķirtu “ptr”. Pēc tam programma izvada šo atmiņas adresi, parādot 'adreses' operatora pamatdarbību.
Pēc tam tiek deklarēts jauns vesela skaitļa mainīgais, kas ir “retrievedValue”, un tiek izmantots netiešās darbības operators (*), lai izgūtu vērtību, kas saglabāta atmiņas adresē, kas norādīta ar “ptr”. Pēc tam izgūtā vērtība tiek izvadīta uz konsoli.
Secinājums
Šis raksts sniedza visaptverošu unāro operatoru izpēti C++. Mēs sākām, iedalot unāros operatorus dažādos veidos, tostarp aritmētiskajos, loģiskajos, bitu pakāpēs un tajos, kas saistīti ar adresi un netiešo. Tika parādītas reālās situācijas, lai parādītu šo operatoru lietderīgo pielietojumu. Šie operatori spēlē galveno lomu C++ programmēšanā, kas ļauj izstrādātājiem efektīvi strādāt ar rādītājiem un pārvaldīt atmiņu.