C++ ondersteunt verschillende unaire operatoren, die elk een uniek doel dienen bij het manipuleren van de variabelen. Laten we beginnen met de operatoren voor verhogen en verlagen die vaak worden gebruikt in lussen en verschillende algoritmen.
Voorbeeld 1: Operatoren voor verhogen (++) en verlagen (–).
De unaire operatoren verhogen (++) en verlagen (–) zijn fundamentele hulpmiddelen in C++ voor het wijzigen van de waarde van een variabele door deze respectievelijk met 1 te verhogen of te verlagen. De operator voor verhogen (++) telt 1 op bij de waarde van de variabele, terwijl de operator voor verlagen (–) 1 aftrekt. Deze operators kunnen worden toegepast op integer-, drijvende-komma- en pointervariabelen, waardoor flexibiliteit in het gebruik ervan wordt geboden.
Laten we deze operatoren verkennen aan de hand van een praktisch voorbeeld:
#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
int balie = 0 ;
// Verhogingsoperator
uit << 'Beginwaarde: ' << balie << eindl ;
balie ++ ;
uit << 'Waarde na verhoging: ' << balie << eindl ;
// Operator verlagen
balie -- ;
uit << 'Waarde na verlaging: ' << balie << eindl ;
opbrengst 0 ;
}
Dit eenvoudige C++-programma bevat de benodigde input/output-streambibliotheek met “#include
Na deze bewerking wordt de bijgewerkte waarde van “counter” weergegeven met behulp van een andere “cout”-instructie. Vervolgens gebruiken we de decrement-operator (counter—) om de waarde van “counter” met 1 te verlagen. De uitkomst wordt vervolgens op de console weergegeven. Uiteindelijk wordt het programma afgesloten met de “return 0;” verklaring die een succesvolle uitvoering aangeeft.
Het uitvoerbeeld toont de beginwaarde, de waarde na de verhoging en de verlaagde waarde.
Voorbeeld 2: Positieve (+) en negatieve (-) operatoren
Hoewel de positieve unaire operator zelden wordt gebruikt, is de negatieve operator van fundamenteel belang voor het veranderen van het teken van een variabele.
#includeGebruik makend van naamruimte soa ;
int voornaamst ( ) {
int positieveWaarde = 10 ;
int negatieveWaarde = - positieveWaarde ;
uit << 'Positieve waarde: ' << positieveWaarde << eindl ;
uit << 'Negatieve waarde: ' << negatieveWaarde << eindl ;
opbrengst 0 ;
}
We initialiseren twee gehele variabelen voor deze voorbeeldcode, namelijk 'positiveValue' en 'negativeValue'. Aan de “positieveWaarde” wordt de waarde 10 toegekend. Vervolgens declareren we de “negatieveWaarde” en wijzen deze toe met de ontkenning van “positieveWaarde” met behulp van de unaire min-operator. Deze operator verandert effectief het teken van de oorspronkelijke waarde. Vervolgens gebruiken we de “cout”-instructie om zowel de positieve als de negatieve uitvoer op de console weer te geven. Ten slotte retourneert het programma 0, wat de succesvolle voltooiing van de hoofdfunctie aangeeft.
Wanneer dit programma wordt uitgevoerd, worden de positieve en negatieve waarden weergegeven.
Voorbeeld 3: Logische NOT (!) Operator
De unaire operator in C++, aangegeven met de “!” symbool, staat bekend als de logische NOT-operator. Het is ontworpen om de waarheidswaarde van een bepaalde uitdrukking om te keren. Het werkt op een enkele operand, die doorgaans een logische uitdrukking of voorwaarde is. De logische NOT-bewerking levert een “ware” uitkomst op als de operand “false” is en levert een “false” uitkomst op als de operand “true” is.
Hier is een eenvoudig voorbeeld dat het gebruik van de logische NOT-operator demonstreert:
#includegebruik makend van naamruimte soa ;
int voornaamst ( ) {
bool is waar = WAAR ;
bool is fout = vals ;
bool resultaatNietWaar = ! is waar ;
bool resultaatNietFalse = ! is fout ;
uit << 'Originele waarde: ' << is waar << ', Na NIET: ' << resultaatNietWaar << eindl ;
uit << 'Originele waarde: ' << is fout << ', Na NIET: ' << resultaatNietFalse << eindl ;
opbrengst 0 ;
}
In dit voorbeeld declareren we twee Booleaanse variabelen, “isTrue” en “isFalse”. Vervolgens passen we de logische NOT-operator toe op elke variabele, waarbij de resultaten respectievelijk worden opgeslagen in “resultNotTrue” en “resultNotFalse”. Het programma drukt vervolgens voor beide variabelen de oorspronkelijke waarden en de resultaten van de logische NOT-bewerking af.
Bij het uitvoeren van dit programma zullen we merken dat de logische NOT-operator de waarheidswaarde van “isTrue” omkeert (aanvankelijk ingesteld op true), waardoor deze onwaar wordt. Op dezelfde manier keert het de waarheidswaarde van “isFalse” (oorspronkelijk onwaar) om, waardoor waar wordt verkregen.
De uitvoer illustreert duidelijk de omkering van de waarheidswaarden die worden bereikt door de logische NOT-operator.
Voorbeeld 4: Bitsgewijze NOT (~) Operator
De bitsgewijze NOT-operator (~) in C++ is een unaire operator die de bitsgewijze negatie van elk bit van zijn operand uitvoert. Het werkt met fundamentele gegevenstypen, met name integrale gegevens, zoals gehele getallen. Het resultaat wordt bereikt door elke individuele bit in de operand te inverteren, waarbij nullen worden omgezet in 1s en 1s in 0s.
Bekijk het volgende codefragment om het gebruik ervan te illustreren:
#includegebruik makend van naamruimte soa ;
int voornaamst ( ) {
int originele waarde = 5 ;
int resultaatBitwiseNot = ~oorspronkelijkewaarde ;
uit << 'Originele waarde: ' << originele waarde << ', Na Bitwise NIET: ' << resultaatBitwiseNot << eindl ;
opbrengst 0 ;
}
In dit voorbeeld declareren we een geheel getalvariabele “originalValue” met de waarde “5”. Vervolgens gebruiken we de bitsgewijze NOT-operator (~) voor deze variabele. Het resultaat van deze variabele wordt opgeslagen in “resultBitwiseNot”. Het programma drukt vervolgens de oorspronkelijke waarde en het resultaat af na de bitsgewijze NOT-bewerking door gebruik te maken van de “cout”-instructie.
Wanneer we dit programma uitvoeren, zullen we zien dat de bitsgewijze NOT-operator elke bit van de binaire representatie van “originalValue” omkeert, wat resulteert in een nieuwe waarde.
Voorbeeld 5: Adres- en indirecte operators
De adres-van-operator, aangegeven met het “&”-symbool, dient voor het ophalen van de geheugenlocatie van een variabele. Het retourneert een verwijzing naar de variabele die indirecte toegang tot de waarde ervan mogelijk maakt. De indirectie- of dereferentie-operator (*) verkrijgt de waarde die is opgeslagen op de geheugenlocatie die is opgegeven door een aanwijzer. Het biedt een manier om indirect met de feitelijke gegevens te werken via een aanwijzer.
Laten we het concept begrijpen met een voorbeeld:
#includegebruik makend van naamruimte soa ;
int voornaamst ( ) {
int waarde = 99 ;
uit << 'Originele waarde: ' << waarde << eindl ;
int * ptr = & waarde ;
uit << 'Geheugenadres: ' << ptr << eindl ;
int opgehaalde waarde = * ptr ;
uit << 'Opgehaalde waarde:' << opgehaalde waarde << eindl ;
opbrengst 0 ;
}
Deze code illustreert het gebruik van adres- en indirectie-operatoren. Eerst wordt een geheel getalvariabele met de naam “value” geïnitialiseerd met de waarde 99. De oorspronkelijke waarde van “value” wordt vervolgens naar de console uitgevoerd. Vervolgens wordt een pointervariabele “ptr” gedeclareerd, en wordt de operator adres-van (&) gebruikt om het geheugenadres “waarde” toe te wijzen aan “ptr”. Het programma voert vervolgens dit geheugenadres uit, waarmee de basiswerking van de “adres”-operator wordt getoond.
Daarna wordt een nieuwe integer-variabele genaamd “retrievedValue” gedeclareerd, en wordt de indirectie-operator (*) gebruikt om de waarde op te halen die is opgeslagen op het geheugenadres waarnaar wordt verwezen door “ptr”. De opgehaalde waarde wordt vervolgens naar de console uitgevoerd.
Conclusie
Dit artikel biedt een uitgebreide verkenning van unaire operatoren in C++. We zijn begonnen met het categoriseren van de unaire operatoren in verschillende typen, waaronder rekenkundige, logische, bitgewijze en operatoren die verband houden met adres en indirectie. Er werden voorbeelden uit de echte wereld gegeven om de nuttige toepassing van deze operatoren aan te tonen. Deze operators spelen een cruciale rol bij het programmeren in C++, waardoor de ontwikkelaars efficiënt met pointers kunnen werken en het geheugen kunnen beheren.