C++ unterstützt mehrere unäre Operatoren, von denen jeder einen einzigartigen Zweck bei der Manipulation der Variablen erfüllt. Beginnen wir mit den Inkrementierungs- und Dekrementierungsoperatoren, die üblicherweise in Schleifen und verschiedenen Algorithmen verwendet werden.
Beispiel 1: Inkrementierungs- (++) und Dekrementierungsoperatoren (–).
Die unären Inkrement- (++) und Dekrementierungsoperatoren (–) sind grundlegende Werkzeuge in C++ zum Ändern des Werts einer Variablen, indem sie ihn entweder um 1 erhöhen oder verringern. Der Inkrementoperator (++) addiert 1 zum Wert der Variablen, während der Dekrementoperator (–) 1 subtrahiert. Diese Operatoren können auf Ganzzahl-, Gleitkomma- und Zeigervariablen angewendet werden und bieten so Flexibilität bei der Verwendung.
Lassen Sie uns diese Operatoren anhand eines praktischen Beispiels untersuchen:
#include
verwenden Namensraum std ;
int hauptsächlich ( )
{
int Schalter = 0 ;
// Inkrementoperator
cout << 'Ursprünglicher Wert: ' << Schalter << endl ;
Schalter ++ ;
cout << „Wert nach Erhöhung:“ << Schalter << endl ;
// Dekrementoperator
Schalter -- ;
cout << „Wert nach Dekrementierung:“ << Schalter << endl ;
zurückkehren 0 ;
}
Dieses einfache C++-Programm enthält die erforderliche Eingabe-/Ausgabe-Stream-Bibliothek mit „#include
Nach diesem Vorgang wird der aktualisierte Wert von „counter“ mithilfe einer weiteren „cout“-Anweisung angezeigt. Anschließend verwenden wir den Dekrementoperator (counter-), um den Wert von „counter“ um 1 zu verringern. Das Ergebnis wird anschließend auf der Konsole angezeigt. Letztendlich endet das Programm mit der „return 0;“ Anweisung, die eine erfolgreiche Ausführung anzeigt.
Das Ausgabebild zeigt den Anfangswert, den Wert nach dem Inkrement und den dekrementierten Wert.
Beispiel 2: Positive (+) und negative (-) Operatoren
Während der positive unäre Operator selten verwendet wird, ist der negative Operator von grundlegender Bedeutung für die Änderung des Vorzeichens einer Variablen.
#includeBenutzen Namensraum std ;
int hauptsächlich ( ) {
int positiver Wert = 10 ;
int negativer Wert = - positiver Wert ;
cout << „Positiver Wert:“ << positiver Wert << endl ;
cout << 'Negativer Wert: ' << negativer Wert << endl ;
zurückkehren 0 ;
}
Wir initialisieren zwei ganzzahlige Variablen für diesen Beispielcode, nämlich „positiveValue“ und „negativeValue“. Dem „positiveValue“ wird der Wert 10 zugewiesen. Anschließend deklarieren wir den „negativeValue“ und weisen ihm die Negation von „positiveValue“ mit dem unären Minusoperator zu. Dieser Operator ändert effektiv das Vorzeichen des ursprünglichen Werts. Anschließend verwenden wir die „cout“-Anweisung, um sowohl die positive als auch die negative Ausgabe auf der Konsole anzuzeigen. Schließlich gibt das Programm 0 zurück, was den erfolgreichen Abschluss der Hauptfunktion anzeigt.
Bei der Ausführung gibt dieses Programm die positiven und negativen Werte aus.
Beispiel 3: Logischer NOT(!)-Operator
Der unäre Operator in C++, gekennzeichnet durch das „!“ Symbol, wird als logischer NOT-Operator bezeichnet. Es dient dazu, den Wahrheitswert eines bestimmten Ausdrucks umzukehren. Es arbeitet mit einem einzelnen Operanden, bei dem es sich typischerweise um einen logischen Ausdruck oder eine Bedingung handelt. Die logische NICHT-Operation liefert ein „wahres“ Ergebnis, wenn der Operand „falsch“ ist, und ein „falsches“ Ergebnis, wenn der Operand „wahr“ ist.
Hier ist ein einfaches Beispiel, das die Verwendung des logischen NOT-Operators demonstriert:
#includeverwenden Namensraum std ;
int hauptsächlich ( ) {
bool ist wahr = WAHR ;
bool ist falsch = FALSCH ;
bool resultNotTrue = ! ist wahr ;
bool resultNotFalse = ! ist falsch ;
cout << 'Originalwert: ' << ist wahr << ', Nach NICHT: ' << resultNotTrue << endl ;
cout << 'Originalwert: ' << ist falsch << ', Nach NICHT: ' << resultNotFalse << endl ;
zurückkehren 0 ;
}
In diesem Beispiel deklarieren wir zwei boolesche Variablen, „isTrue“ und „isFalse“. Anschließend wenden wir den logischen NOT-Operator auf jede Variable an und speichern die Ergebnisse in „resultNotTrue“ bzw. „resultNotFalse“. Anschließend gibt das Programm die Originalwerte und die Ergebnisse der logischen NICHT-Operation für beide Variablen aus.
Beim Ausführen dieses Programms werden wir feststellen, dass der logische NOT-Operator den Wahrheitswert von „isTrue“ (ursprünglich auf „true“ gesetzt) umkehrt und ihn zu „false“ macht. Auf ähnliche Weise wird der Wahrheitswert von „isFalse“ (ursprünglich falsch) invertiert, was „true“ ergibt.
Die Ausgabe veranschaulicht deutlich die Umkehrung der Wahrheitswerte, die durch den logischen NICHT-Operator erreicht wird.
Beispiel 4: Bitweiser NOT-Operator (~).
Der bitweise NOT-Operator (~) in C++ ist ein unärer Operator, der die bitweise Negation jedes Bits seines Operanden durchführt. Es funktioniert mit grundlegenden Datentypen, insbesondere mit ganzzahligen Datentypen wie Ganzzahlen. Das Ergebnis wird dadurch erreicht, dass jedes einzelne Bit im Operanden invertiert wird und 0en in 1en und 1en in 0en umgewandelt werden.
Betrachten Sie zur Veranschaulichung der Verwendung den folgenden Codeausschnitt:
#includeverwenden Namensraum std ;
int hauptsächlich ( ) {
int Originalwert = 5 ;
int resultBitwiseNot = ~originalValue ;
cout << 'Originalwert: ' << Originalwert << ', Nach Bitwise NOT: ' << resultBitwiseNot << endl ;
zurückkehren 0 ;
}
In diesem Beispiel deklarieren wir eine Ganzzahlvariable „originalValue“ mit dem Wert „5“. Als nächstes verwenden wir den bitweisen NOT-Operator (~) für diese Variable. Das Ergebnis dieser Variablen wird in „resultBitwiseNot“ gespeichert. Das Programm gibt dann den ursprünglichen Wert und das Ergebnis nach der bitweisen NOT-Operation aus, indem es die Anweisung „cout“ verwendet.
Wenn wir dieses Programm ausführen, werden wir sehen, dass der bitweise NOT-Operator jedes Bit der binären Darstellung von „originalValue“ invertiert, was zu einem neuen Wert führt.
Beispiel 5: Adress- und Indirektionsoperatoren
Der Adressoperator, gekennzeichnet durch das „&“-Symbol, dient dazu, den Speicherort einer Variablen abzurufen. Es gibt einen Zeiger auf die Variable zurück, der einen indirekten Zugriff auf ihren Wert ermöglicht. Der Indirektions- oder Dereferenzierungsoperator (*) ruft den Wert ab, der an der durch einen Zeiger angegebenen Speicherstelle gespeichert ist. Es bietet eine Möglichkeit, indirekt über einen Zeiger mit den tatsächlichen Daten zu arbeiten.
Lassen Sie uns das Konzept anhand eines Beispiels verstehen:
#includeverwenden Namensraum std ;
int hauptsächlich ( ) {
int Wert = 99 ;
cout << 'Originalwert: ' << Wert << endl ;
int * ptr = & Wert ;
cout << „Speicheradresse:“ << ptr << endl ;
int abgerufener Wert = * ptr ;
cout << „Abgerufener Wert:“ << abgerufener Wert << endl ;
zurückkehren 0 ;
}
Dieser Code veranschaulicht die Verwendung von Adress- und Indirektionsoperatoren. Zunächst wird eine Integer-Variable namens „value“ mit dem Wert 99 initialisiert. Anschließend wird der ursprüngliche Wert von „value“ an die Konsole ausgegeben. Anschließend wird eine „ptr“-Zeigervariable deklariert und der Adressenoperator (&) verwendet, um „ptr“ die Speicheradresse von „value“ zuzuweisen. Das Programm gibt dann diese Speicheradresse aus und demonstriert die grundlegende Funktionsweise des „Adressen“-Operators.
Danach wird eine neue Ganzzahlvariable mit dem Namen „retrievedValue“ deklariert und der Indirektionsoperator (*) verwendet, um den Wert abzurufen, der an der durch „ptr“ angegebenen Speicheradresse gespeichert ist. Der abgerufene Wert wird dann an die Konsole ausgegeben.
Abschluss
Dieser Artikel bietet eine umfassende Untersuchung unärer Operatoren in C++. Wir begannen damit, die unären Operatoren in verschiedene Typen zu kategorisieren, darunter arithmetische, logische, bitweise und solche, die sich auf Adresse und Indirektion beziehen. Es wurden reale Situationen veranschaulicht, um die nützliche Anwendung dieser Operatoren zu demonstrieren. Diese Operatoren spielen eine zentrale Rolle in der C++-Programmierung und ermöglichen es den Entwicklern, effizient mit Zeigern zu arbeiten und den Speicher zu verwalten.