C++ understøtter flere unære operatorer, der hver tjener et unikt formål med at manipulere variablerne. Lad os starte med inkrement- og dekrementoperatorerne, som almindeligvis bruges i sløjfer og forskellige algoritmer.
Eksempel 1: Forøg (++) og formindsk (–) operatører
Increment (++) og decrement (–) unære operatorer er grundlæggende værktøjer i C++ til at ændre værdien af en variabel ved enten at øge eller mindske den med henholdsvis 1. Increment-operatoren (++) tilføjer 1 til variablens værdi, mens dekrementoperatoren (–) trækker 1 fra. Disse operatorer kan anvendes på heltal-, flydende-komma- og pointervariabler, hvilket giver fleksibilitet i deres brug.
Lad os udforske disse operatører gennem et praktisk eksempel:
#include
ved brug af navneområde std ;
int vigtigste ( )
{
int tæller = 0 ;
// Increment operator
cout << 'Startværdi: ' << tæller << endl ;
tæller ++ ;
cout << 'Værdi efter stigning: ' << tæller << endl ;
// Decrement operator
tæller -- ;
cout << 'Værdi efter fald: ' << tæller << endl ;
Vend tilbage 0 ;
}
Dette simple C++-program inkluderer det nødvendige input/output stream-bibliotek med '#include
Efter denne handling vises den opdaterede værdi af 'tæller' ved hjælp af en anden 'cout'-sætning. Efterfølgende bruger vi decrement-operatoren (tæller—) til at reducere værdien af 'tæller' med 1. Resultatet vises efterfølgende på konsollen. I sidste ende afsluttes programmet med 'retur 0;' erklæring, der indikerer en vellykket eksekvering.
Outputbilledet viser startværdien, værdien efter stigningen og den reducerede værdi.
Eksempel 2: Positive (+) og negative (-) operatører
Mens den positive unære operator sjældent bruges, er den negative operator fundamental for at ændre tegnet for en variabel.
#includeVed brug af navneområde std ;
int vigtigste ( ) {
int positiv værdi = 10 ;
int negativ værdi = - positiv værdi ;
cout << 'Positiv værdi: ' << positiv værdi << endl ;
cout << 'Negativ værdi: ' << negativ værdi << endl ;
Vend tilbage 0 ;
}
Vi initialiserer to heltalsvariabler for denne eksempelkode, som er 'positiveValue' og 'negativeValue'. 'positiveValue' tildeles med værdien 10. Efterfølgende erklærer vi 'negativeValue' og tildeler den med negationen af 'positiveValue' ved at bruge den unære minusoperator. Denne operator ændrer effektivt tegnet for den oprindelige værdi. Vi bruger derefter 'cout'-sætningen til at vise både det positive og det negative output på konsollen. Til sidst returnerer programmet 0, hvilket indikerer, at hovedfunktionen er gennemført.
Når det udføres, udsender dette program de positive og negative værdier.
Eksempel 3: Logisk IKKE (!) Operatør
Den unære operator i C++, angivet med '!' symbol, er kendt som den logiske NOT-operator. Det er designet til at invertere sandhedsværdien af et givet udtryk. Den opererer på en enkelt operand, som typisk er et logisk udtryk eller en betingelse. Den logiske NOT-operation giver et 'sandt' udfald, når operanden er 'falskt', og giver et 'falskt' resultat, når operanden er 'sandt'.
Her er et simpelt eksempel, der demonstrerer brugen af den logiske NOT-operator:
#includeved brug af navneområde std ;
int vigtigste ( ) {
bool er sandt = rigtigt ;
bool isFalse = falsk ;
bool resultatNotTrue = ! er sandt ;
bool resultatIkke Falsk = ! isFalse ;
cout << 'Oprindelig værdi: ' << er sandt << ', Efter IKKE: ' << resultatNotTrue << endl ;
cout << 'Oprindelig værdi: ' << isFalse << ', Efter IKKE: ' << resultatIkke Falsk << endl ;
Vend tilbage 0 ;
}
I dette eksempel erklærer vi to boolske variable, 'isTrue' og 'isFalse'. Vi anvender derefter den logiske NOT-operator på hver variabel, og gemmer resultaterne i henholdsvis 'resultNotTrue' og 'resultNotFalse'. Programmet udskriver efterfølgende de originale værdier og resultaterne af den logiske NOT-operation for begge variabler.
Ved udførelse af dette program vil vi bemærke, at den logiske NOT-operator vender sandhedsværdien af 'isTrue' (initielt sat til sand), hvilket gør den falsk. På samme måde inverterer den sandhedsværdien af 'isFalse' (oprindeligt falsk), hvilket giver sand.
Outputtet illustrerer tydeligt inversionen af de sandhedsværdier, der opnås af den logiske NOT-operator.
Eksempel 4: Bitwise NOT (~) Operator
Den bitvise NOT-operator (~) i C++ er en unær operator, der udfører den bitvise negation af hver bit af dens operand. Det fungerer med grundlæggende datatyper, specifikt integrale, såsom heltal. Resultatet opnås ved at invertere hver enkelt bit i operanden, konvertere 0'ere til 1'ere og 1'ere til 0'ere.
Overvej følgende kodestykke for at illustrere brugen:
#includeved brug af navneområde std ;
int vigtigste ( ) {
int originalværdi = 5 ;
int resultatBitwiseNot = ~originalVærdi ;
cout << 'Oprindelig værdi: ' << originalværdi << ', Efter Bitwise NOT: ' << resultatBitwiseNot << endl ;
Vend tilbage 0 ;
}
I dette eksempel erklærer vi en 'originalValue' heltalsvariabel med værdien '5'. Dernæst bruger vi den bitvise NOT-operator (~) på denne variabel. Resultatet af denne variabel gemmes i 'resultBitwiseNot'. Programmet udskriver derefter den oprindelige værdi og resultatet efter den bitvise NOT-operation ved at bruge 'cout'-sætningen.
Når vi kører dette program, vil vi se, at den bitvise NOT-operator inverterer hver bit af den binære repræsentation af 'originalValue', hvilket resulterer i en ny værdi.
Eksempel 5: Adresse- og indirektionsoperatører
Operatorens adresse, angivet med '&' symbolet, tjener det formål at hente hukommelsesplaceringen af en variabel. Det returnerer en pointer til variablen, som muliggør en indirekte adgang til dens værdi. Indirektions- eller dereferenceoperatoren (*) opnår den værdi, der er gemt på den hukommelsesplacering, der er angivet af en markør. Det giver en måde at arbejde med de faktiske data gennem en pointer indirekte.
Lad os forstå konceptet med et eksempel:
#includeved brug af navneområde std ;
int vigtigste ( ) {
int værdi = 99 ;
cout << 'Oprindelig værdi: ' << værdi << endl ;
int * ptr = & værdi ;
cout << 'Hukommelsesadresse:' << ptr << endl ;
int hentetVærdi = * ptr ;
cout << 'Hentet værdi: ' << hentetVærdi << endl ;
Vend tilbage 0 ;
}
Denne kode eksemplificerer brugen af adresse- og indirektionsoperatører. Først initialiseres en heltalsvariabel ved navn 'værdi' med værdien 99. Den oprindelige værdi af 'værdi' udsendes derefter til konsollen. Efterfølgende erklæres en 'ptr' pointervariabel, og adressen-of-operatøren (&) bruges til at tildele hukommelsesadressen for 'værdi' til 'ptr'. Programmet udsender derefter denne hukommelsesadresse, hvilket viser den grundlæggende betjening af 'adresse'-operatøren.
Derefter erklæres en ny heltalsvariabel, som er 'retrievedValue', og indirektionsoperatoren (*) bruges til at hente den værdi, der er gemt på hukommelsesadressen, der peges af 'ptr'. Den hentede værdi udsendes derefter til konsollen.
Konklusion
Denne artikel gav en omfattende udforskning af unære operatører i C++. Vi startede med at kategorisere unære operatorer i forskellige typer, herunder aritmetiske, logiske, bitvise og dem, der er relateret til adresse og indirekte. Situationer i den virkelige verden blev eksemplificeret for at demonstrere den nyttige anvendelse af disse operatører. Disse operatører spiller afgørende roller i C++-programmering, som giver udviklerne mulighed for at arbejde med pointere effektivt og administrere hukommelsen.