C++ støtter flere unære operatører, som hver tjener et unikt formål med å manipulere variablene. La oss starte med inkrement- og dekrementoperatorene som vanligvis brukes i løkker og forskjellige algoritmer.
Eksempel 1: Øk (++) og Reduser (–) operatører
Inkrement (++) og dekrement (–) unære operatorer er grunnleggende verktøy i C++ for å endre verdien av en variabel ved å enten øke eller redusere den med 1, henholdsvis. Inkrementoperatoren (++) legger til 1 til variabelens verdi, mens dekrementeringsoperatoren (–) trekker fra 1. Disse operatorene kan brukes på heltalls-, flyttalls- og pekervariabler, noe som gir fleksibilitet i bruken.
La oss utforske disse operatørene gjennom et praktisk eksempel:
#include
ved hjelp av navneområde std ;
int hoved- ( )
{
int disk = 0 ;
// Inkrementoperatør
cout << 'Opprinnelig verdi: ' << disk << endl ;
disk ++ ;
cout << 'Verdi etter økning: ' << disk << endl ;
// Dekrementeringsoperatør
disk -- ;
cout << 'Verdi etter reduksjon: ' << disk << endl ;
komme tilbake 0 ;
}
Dette enkle C++-programmet inkluderer det nødvendige input/output-strømbiblioteket med '#include
Etter denne operasjonen vises den oppdaterte verdien av 'teller' ved hjelp av en annen 'cout'-setning. Deretter bruker vi dekrementeringsoperatøren (teller—) for å redusere verdien av 'teller' med 1. Resultatet vises deretter på konsollen. Til syvende og sist avsluttes programmet med 'retur 0;' uttalelse som indikerer en vellykket utførelse.
Utdatabildet viser startverdien, verdien etter økningen og den reduserte verdien.
Eksempel 2: Positive (+) og negative (-) operatører
Mens den positive unære operatoren sjelden brukes, er den negative operatoren grunnleggende for å endre tegnet til en variabel.
#includeVed hjelp av navneområde std ;
int hoved- ( ) {
int positiv Verdi = 10 ;
int negativ Verdi = - positiv Verdi ;
cout << 'Positiv verdi: ' << positiv Verdi << endl ;
cout << 'Negativ verdi: ' << negativ Verdi << endl ;
komme tilbake 0 ;
}
Vi initialiserer to heltallsvariabler for denne eksempelkoden som er 'positiveValue' og 'negativeValue'. 'Positivverdien' tildeles verdien 10. Deretter erklærer vi 'negativverdien' og tilordner den med negasjonen av 'positivverdi' ved å bruke den unære minusoperatoren. Denne operatøren endrer effektivt tegnet til den opprinnelige verdien. Vi bruker deretter 'cout'-setningen for å vise både den positive og den negative utgangen på konsollen. Til slutt returnerer programmet 0 som indikerer vellykket fullføring av hovedfunksjonen.
Når det kjøres, sender dette programmet de positive og negative verdiene.
Eksempel 3: Logisk IKKE (!) Operatør
Den unære operatoren i C++, betegnet med '!' symbol, er kjent som den logiske NOT-operatoren. Den er designet for å invertere sannhetsverdien til et gitt uttrykk. Den opererer på en enkelt operand som vanligvis er et logisk uttrykk eller en betingelse. Den logiske NOT-operasjonen gir et 'sant' utfall når operanden er 'falsk' og gir et 'falsk' utfall når operanden er 'sann'.
Her er et enkelt eksempel som viser bruken av den logiske NOT-operatoren:
#includeved hjelp av navneområde std ;
int hoved- ( ) {
bool er sant = ekte ;
bool er falsk = falsk ;
bool resultNotTrue = ! er sant ;
bool resultatNotFalse = ! er falsk ;
cout << 'Opprinnelig verdi: ' << er sant << ', Etter IKKE: ' << resultNotTrue << endl ;
cout << 'Opprinnelig verdi: ' << er falsk << ', Etter IKKE: ' << resultatNotFalse << endl ;
komme tilbake 0 ;
}
I dette eksemplet erklærer vi to boolske variabler, 'isTrue' og 'isFalse'. Vi bruker deretter den logiske NOT-operatoren på hver variabel, og lagrer resultatene i henholdsvis 'resultNotTrue' og 'resultNotFalse'. Programmet skriver deretter ut de opprinnelige verdiene og resultatene av den logiske NOT-operasjonen for begge variablene.
Når du kjører dette programmet, vil vi legge merke til at den logiske NOT-operatoren reverserer sannhetsverdien til 'isTrue' (opprinnelig satt til true), og gjør den falsk. På samme måte inverterer den sannhetsverdien til 'isFalse' (opprinnelig usann), og gir sann.
Utgangen illustrerer tydelig inversjonen av sannhetsverdiene som oppnås av den logiske NOT-operatoren.
Eksempel 4: Bitvis IKKE (~) Operatør
Den bitvise NOT-operatoren (~) i C++ er en unær operator som utfører den bitvise negasjonen av hver bit i operanden. Den fungerer med grunnleggende datatyper, spesielt integrerte, for eksempel heltall. Resultatet oppnås ved å invertere hver enkelt bit i operanden, konvertere 0s til 1s og 1s til 0s.
For å illustrere bruken, vurder følgende kodebit:
#includeved hjelp av navneområde std ;
int hoved- ( ) {
int originalverdi = 5 ;
int resultatBitvisIkke = ~originalValue ;
cout << 'Opprinnelig verdi: ' << originalverdi << ', Etter Bitwise NOT: ' << resultatBitvisIkke << endl ;
komme tilbake 0 ;
}
I dette eksemplet erklærer vi en 'originalValue' heltallsvariabel med verdien '5'. Deretter bruker vi den bitvise NOT-operatoren (~) på denne variabelen. Resultatet av denne variabelen lagres i 'resultBitwiseNot'. Programmet skriver deretter ut den opprinnelige verdien og resultatet etter den bitvise NOT-operasjonen ved å bruke 'cout'-setningen.
Når vi kjører dette programmet, vil vi se at den bitvise NOT-operatoren inverterer hver bit av den binære representasjonen av 'originalValue', noe som resulterer i en ny verdi.
Eksempel 5: Adresse- og indirektionsoperatører
Adressen til operatøren, angitt med '&'-symbolet, tjener hensikten med å hente minneplasseringen til en variabel. Den returnerer en peker til variabelen som muliggjør indirekte tilgang til verdien. Indirektions- eller derereferanseoperatoren (*) henter verdien som er lagret på minneplasseringen som er spesifisert av en peker. Det gir en måte å arbeide med de faktiske dataene gjennom en peker indirekte.
La oss forstå konseptet med et eksempel:
#includeved hjelp av navneområde std ;
int hoved- ( ) {
int verdi = 99 ;
cout << 'Opprinnelig verdi: ' << verdi << endl ;
int * ptr = & verdi ;
cout << 'Minneadresse: ' << ptr << endl ;
int hentet Verdi = * ptr ;
cout << 'Hentet verdi: ' << hentet Verdi << endl ;
komme tilbake 0 ;
}
Denne koden eksemplifiserer bruken av adresse- og indirektionsoperatører. Først initialiseres en heltallsvariabel kalt 'verdi' med verdien 99. Den opprinnelige verdien av 'verdi' sendes deretter ut til konsollen. Deretter erklæres en 'ptr'-pekervariabel, og adressen til operatoren (&) brukes til å tilordne minneadressen til 'verdi' til 'ptr'. Programmet sender deretter ut denne minneadressen, og viser den grunnleggende operasjonen til 'adresse'-operatøren.
Deretter deklareres en ny heltallsvariabel som er 'retrievedValue', og indirektionsoperatøren (*) brukes for å hente verdien som er lagret på minneadressen pekt av 'ptr'. Den hentede verdien sendes deretter til konsollen.
Konklusjon
Denne artikkelen ga en omfattende utforskning av unære operatører i C++. Vi begynte med å kategorisere de unære operatorene i ulike typer, inkludert aritmetikk, logisk, bitvis og de som er relatert til adresse og indirektion. Situasjoner i den virkelige verden ble eksemplifisert for å demonstrere den nyttige anvendelsen av disse operatørene. Disse operatørene spiller sentrale roller i C++-programmering som lar utviklerne jobbe med pekere effektivt og administrere minnet.