C++-Operatoren

In diesem Tutorial lernen wir anhand von Beispielen die verschiedenen Arten von Operatoren in C++ kennen. In der Programmierung ist ein Operator ein Symbol, das einen Wert oder eine Variable bearbeitet.

Operatoren sind Symbole, die Operationen an Variablen und Werten ausführen. Beispiel:+ ist ein Operator für die Addition, während - ist ein Operator für die Subtraktion.

Operatoren in C++ können in 6 Typen eingeteilt werden:

Arithmetische Operatoren
Zuweisungsoperatoren
Relationale Operatoren
Logische Operatoren
Bitweise Operatoren
Andere Betreiber

1. Arithmetische C++-Operatoren

Arithmetische Operatoren werden verwendet, um arithmetische Operationen an Variablen und Daten durchzuführen. Zum Beispiel

a + b;

Hier die + Operator wird verwendet, um zwei Variablen a hinzuzufügen und b . Ebenso gibt es in C++ verschiedene andere arithmetische Operatoren.

Operator	Vorgang
`+`	Zusatz
`-`	Subtraktion
`*`	Multiplikation
`/`	Abteilung
`%`	Modulo-Operation (Rest nach Division)

Beispiel 1:Arithmetische Operatoren

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 7;
    b = 2;

    // printing the sum of a and b
    cout << "a + b = " << (a + b) << endl;

    // printing the difference of a and b
    cout << "a - b = " << (a - b) << endl;

    // printing the product of a and b
    cout << "a * b = " << (a * b) << endl;

    // printing the division of a by b
    cout << "a / b = " << (a / b) << endl;

    // printing the modulo of a by b
    cout << "a % b = " << (a % b) << endl;

    return 0;
}

Ausgabe

a + b = 9
a - b = 5
a * b = 14
a / b = 3
a % b = 1

Hier die Operatoren + , - und * berechnen Addition, Subtraktion bzw. Multiplikation, wie wir es vielleicht erwartet haben.

/ Abteilungsoperator

Beachten Sie die Operation (a / b) in unserem Programm. Die / operator ist der Divisionsoperator.

Wie wir im obigen Beispiel sehen können, erhalten wir den Quotienten, wenn eine ganze Zahl durch eine andere ganze Zahl dividiert wird. Wenn jedoch entweder Divisor oder Dividend eine Fließkommazahl ist, erhalten wir das Ergebnis in Dezimalzahlen.

In C++,

7/2 is 3
7.0 / 2 is 3.5
7 / 2.0 is 3.5
7.0 / 2.0 is 3.5

% Modulo-Operator

Der Modulo-Operator % berechnet den Rest. Wenn a = 9 wird durch b = 4 geteilt , der Rest ist 1 .

Hinweis: Die % Der Operator kann nur mit Ganzzahlen verwendet werden.

Inkrement- und Dekrementoperatoren

C++ bietet auch Inkrement- und Dekrementoperatoren:++ und -- bzw..

++ erhöht den Wert des Operanden um 1
-- verringert ihn um 1

Zum Beispiel

int num = 5;

// increment operator
++num;  // 6

Hier der Code ++num; erhöht den Wert von num um 1 .

Beispiel 2:Inkrement- und Dekrementoperatoren

// Working of increment and decrement operators

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 100, result_a, result_b;

    // incrementing a by 1 and storing the result in result_a
    result_a = ++a;
    cout << "result_a = " << result_a << endl;


    // decrementing b by 1 and storing the result in result_b   
    result_b = --b;
    cout << "result_b = " << result_b << endl;

    return 0;
}

Ausgabe

result_a = 11
result_b = 99

Im obigen Programm haben wir den ++ verwendet und -- Operatoren als Präfixe (++a und --b) . Wir können diese Operatoren jedoch auch als Postfix (a++ und b--) verwenden .

Weitere Informationen finden Sie unter Inkrement- und Dekrementoperatoren.

2. C++-Zuweisungsoperatoren

In C++ werden Zuweisungsoperatoren verwendet, um Variablen Werte zuzuweisen. Zum Beispiel

// assign 5 to a
a = 5;

Hier haben wir einen Wert von 5 zugewiesen in die Variable a .

Operator	Beispiel	Äquivalent zu
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Beispiel 3:Zuweisungsoperatoren

#include <iostream>
using namespace std;

int main() {
    int a, b;

    // 2 is assigned to a
    a = 2;

    // 7 is assigned to b
    b = 7;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "\nAfter a += b;" << endl;

    // assigning the sum of a and b to a
    a += b;  // a = a +b
    cout << "a = " << a << endl;

    return 0;
}

Ausgabe

a = 2
b = 7

After a += b;
a = 9

3. Vergleichsoperatoren in C++

Ein Vergleichsoperator wird verwendet, um die Beziehung zwischen zwei Operanden zu überprüfen. Zum Beispiel

// checks if a is greater than b
a > b;

Hier > ist ein Vergleichsoperator. Es prüft, ob a ist größer als b oder nicht.

Wenn die Beziehung wahr ist , gibt es 1 zurück wohingegen wenn die Beziehung false ist , gibt es 0 zurück .

Operator	Bedeutung	Beispiel
`==`	Ist gleich	`3 == 5` gibt uns false
`!=`	Ungleich	`3 != 5` gibt uns wahr
`>`	Größer als	`3 > 5` gibt uns false
`<`	Kleiner als	`3 < 5` gibt uns wahr
`>=`	Größer als oder gleich	`3 >= 5` gib uns falsch
`<=`	Kleiner als oder gleich	`3 <= 5` gibt uns wahr

Beispiel 4:Vergleichsoperatoren

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 3;
    b = 5;
    bool result;

    result = (a == b);   // false
    cout << "3 == 5 is " << result << endl;

    result = (a != b);  // true
    cout << "3 != 5 is " << result << endl;

    result = a > b;   // false
    cout << "3 > 5 is " << result << endl;

    result = a < b;   // true
    cout << "3 < 5 is " << result << endl;

    result = a >= b;  // false
    cout << "3 >= 5 is " << result << endl;

    result = a <= b;  // true
    cout << "3 <= 5 is " << result << endl;

    return 0;
}

Ausgabe

3 == 5 is 0
3 != 5 is 1
3 > 5 is 0
3 < 5 is 1
3 >= 5 is 0
3 <= 5 is 1

Hinweis :Vergleichsoperatoren werden in Entscheidungsfindungen und Schleifen verwendet.

4. Logische C++-Operatoren

Logische Operatoren werden verwendet, um zu prüfen, ob ein Ausdruck wahr ist oder falsch . Wenn der Ausdruck wahr ist , gibt es 1 zurück wohingegen wenn der Ausdruck false ist , gibt es 0 zurück .

Operator	Beispiel	Bedeutung
`&&`	Ausdruck1 && Ausdruck2	Logisches UND. Nur wahr, wenn alle Operanden wahr sind.
`\|\|`	Ausdruck1 \|\| Ausdruck2	Logisches ODER. Wahr, wenn mindestens einer der Operanden wahr ist.
`!`	! Ausdruck	Logisches NICHT. Nur wahr, wenn der Operand falsch ist.

In C++ werden logische Operatoren häufig zur Entscheidungsfindung verwendet. Um die logischen Operatoren besser zu verstehen, sehen wir uns die folgenden Beispiele an,

Suppose,
a = 5
b = 8

Then,

(a > 3) && (b > 5) evaluates to true
(a > 3)  && (b < 5) evaluates to false

(a > 3) || (b > 5) evaluates to true
(a > 3) || (b < 5) evaluates to true
(a < 3) || (b < 5) evaluates to false

!(a < 3) evaluates to true
!(a > 3) evaluates to false

Beispiel 5:Logische Operatoren

#include <iostream>
using namespace std;

int main() {
    bool result;

    result = (3 != 5) && (3 < 5);     // true
    cout << "(3 != 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 < 5);    // false
    cout << "(3 == 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 > 5);    // false
    cout << "(3 == 5) && (3 > 5) is " << result << endl;

    result = (3 != 5) || (3 < 5);    // true
    cout << "(3 != 5) || (3 < 5) is " << result << endl;

    result = (3 != 5) || (3 > 5);    // true
    cout << "(3 != 5) || (3 > 5) is " << result << endl;

    result = (3 == 5) || (3 > 5);    // false
    cout << "(3 == 5) || (3 > 5) is " << result << endl;

    result = !(5 == 2);    // true
    cout << "!(5 == 2) is " << result << endl;

    result = !(5 == 5);    // false
    cout << "!(5 == 5) is " << result << endl;

    return 0;
}

Ausgabe

(3 != 5) && (3 < 5) is 1
(3 == 5) && (3 < 5) is 0
(3 == 5) && (3 > 5) is 0
(3 != 5) || (3 < 5) is 1
(3 != 5) || (3 > 5) is 1
(3 == 5) || (3 > 5) is 0
!(5 == 2) is 1
!(5 == 5) is 0

Erklärung des logischen Operatorprogramms

(3 != 5) && (3 < 5) ergibt 1 denn beide Operanden (3 != 5) und (3 < 5) sind 1 (wahr).
(3 == 5) && (3 < 5) ergibt 0 weil der Operand (3 == 5) ist 0 (falsch).
(3 == 5) && (3 > 5) ergibt 0 denn beide Operanden (3 == 5) und (3 > 5) sind 0 (falsch).
(3 != 5) || (3 < 5) ergibt 1 denn beide Operanden (3 != 5) und (3 < 5) sind 1 (wahr).
(3 != 5) || (3 > 5) ergibt 1 weil der Operand (3 != 5) ist 1 (wahr).
(3 == 5) || (3 > 5) ergibt 0 denn beide Operanden (3 == 5) und (3 > 5) sind 0 (falsch).
!(5 == 2) ergibt 1 weil der Operand (5 == 2) ist 0 (falsch).
!(5 == 5) ergibt 0 weil der Operand (5 == 5) ist 1 (wahr).

5. Bitweise C++-Operatoren

In C++ werden bitweise Operatoren verwendet, um Operationen an einzelnen Bits auszuführen. Sie können nur zusammen mit char verwendet werden und int Datentypen.

Operator	Beschreibung
`&`	Binäres UND
`\|`	Binäres ODER
`^`	Binäres XOR
`~`	Binäres Einerkomplement
`<<`	Binäre Verschiebung nach links
`>>`	Binäre Verschiebung nach rechts

Weitere Informationen finden Sie unter Bitweise Operatoren in C++.

6. Andere C++-Operatoren

Hier ist eine Liste einiger anderer allgemeiner Operatoren, die in C++ verfügbar sind. Wir werden sie in späteren Tutorials kennenlernen.

Operator	Beschreibung	Beispiel
`sizeof`	gibt die Größe des Datentyps zurück	`sizeof(int); // 4`
`?:`	gibt den Wert basierend auf der Bedingung zurück	`string result = (5 > 0) ? "even" : "odd"; // "even"`
`&`	repräsentiert die Speicheradresse des Operanden	`&num; // address of num`
`.`	greift auf Elemente von Strukturvariablen oder Klassenobjekten zu	`s1.marks = 92;`
`->`	wird mit Zeigern verwendet, um auf die Klassen- oder Strukturvariablen zuzugreifen	`ptr->marks = 92;`
`<<`	druckt den Ausgabewert	`cout << 5;`
`>>`	erhält den Eingabewert	`cin >> num;`

C++-Typkonvertierung C++-Kommentare

C Sprache