Operatoren

Du bist hier: Startseite Entwicklung (C/C++) C++ Grundlagen Operatoren

Operatoren

Arithmetische Operatoren

Mit Arithmetischen Operatoren können Rechenaufgaben durchgeführt werden.

+ Addition
- Subtraktion
* Multiplikation
/ Division
% Modulo (Restwert Berechnung)

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
        int var = 0;
        var = 3 + 9;
        std::cout << var << std::endl;
 
        std::cin.get();
        return EXIT_SUCCESS;
}

Inkrement- und Dekrement-Operatoren

Mit diesen Operatoren kann +1 oder -1 gerechnet werden

++ Erhöhung (increment)
-- Erniedrigung (decrement)

Steht der Operator vor der Variablen, wird zuerst inkrementiert oder dekrementiert und dann auf die Variable zugegriffen. Andernfalls anders rum.

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
        int var = 10;
        std::cout << ++var << std::endl;
 
        std::cin.get();
        return EXIT_SUCCESS;
}

Zuweisungs Operator

Die Zuweisungs Operatoren belegen z.B. eine Variable mit einem Wert.

= Zuweisung
+= Addieren
-= Subtrahieren
*= Multiplizieren
/= Dividieren
%= Modulo (Restwert)

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
        int var = 15;
 
        std::cout << var << std::endl; // 15
	std::cout << (var += 5) << std::endl; // 15+5=20
	std::cout << (var -= 5) << std::endl; // 20-5=15
	std::cout << (var *= 5) << std::endl; // 15*5=75
	std::cout << (var /= 5) << std::endl; // 75/5=15
	std::cout << (var %= 7) << std::endl; // 15%7=1
 
        std::cin.get();
        return EXIT_SUCCESS;
}

Vergleichs Operatoren

Vergleichsoperatoren ermöglichen wie bereits der Name sagt den Vergleich von Werten und Variablen. Vergleichsoperatoren liefern als Ergebnis einen Wahrheitswert zurück - also entweder true oder false. Das Ergebnis hängt davon ab, ob der Vergleich richtig ist oder nicht.

== Gleichheit
!= Ungleichheit
> Größer
< Kleiner
>= Größer-Gleich
<= Kleiner-Gleich

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
	int var = 15;
	bool res;
 
	res = var == 15; // true
	res = var != 15; // false
	res = var < 20;  // true
	res = var > 20;  // false
	res = var >= 15; // true
	res = var <= 10; // false
 
	std::cin.get();
	return EXIT_SUCCESS;
}

Logische Operatoren

Logische Operatoren ermöglichen es, Wahrheitswerte zu verknüpfen. Die logischen Operatoren && und || sind binäre Operatoren, der logische Operator ! ist ein unärer Operator. Unäre Operatoren erwarten nur einen Operanden, während binäre Operatoren zwei Operanden erwarten. Alle 3 Operatoren geben einen booleschen Wert (true oder false) zurück.

&& Logisches UND (and)
|| Logisches ODER (or)
! Logisches NICHT (not, Negation)

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
	int var = 15;
        bool res;
 
	res = (var < 20) && (var > 10); // true
	res = (var == 15) || (var > 100); // true
	res = !false; // true
	res = !true; // false
 
	std::cin.get();
	return EXIT_SUCCESS;
}

Bitwise Operatoren

Die Bitwise Operatoren ermöglichen das Setzen, Löschen und Verschieben von Bits. Dies ist erstmal nicht relevant, um C++ zu lernen!

& Bitwise UND (and)
| Bitwise OR (or)
^ Bitwise Exklusive OR (xor)
~ Bitwise Negation
<< Left Bitshifting (hat nichts mit std::cout << "Text"... zu tun)
>> Right Bitshifting

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
	int i = 15;	             // 00001111
	int s = 40;                  // 00101000
	int k = i & s;	             // 00001000
	std::cout << k << std::endl; // 8
 
        i = 15;		             // 00001111
        s = 40;		             // 00101000
        k = i | s;                   // 00101111
	std::cout << k << std::endl; // 47
 
        i = 15;                      // 00001111
        s = 40;                      // 00101000
        k = i ^ s;                   // 00100111
	std::cout << k << std::endl; // 39
 
        i = 40;                      // 00101000
        k = i << 1;                  // 01010000
        std::cout << k << std::endl; // 80
 
        i = 40;                      // 00101000
        k = i >> 2;                  // 00001010
        std::cout << k << std::endl; // 10
 
	std::cin.get();
	return EXIT_SUCCESS;
}

Präzedenz-Tabelle

Manchmal kommt es vor, dass mehrere Operatoren in einer Zeile vorkommen. Das folgende Beispiel gibt zu überlegen, ob true oder false in r steckt.

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
	bool a, b, c, r;
	a = false;
	b = true;
	c = true;
	r = a && b != c;
	std::cout << r << std::endl;
 
        std::cin.get();
        return EXIT_SUCCESS;
}

Das Ergebnis ist false.
In welcher Reihenfolge Operatoren ausgeführt werden, legt die Präzedenz-Tabelle fest. In dieser ist angegeben, welche Priorität jeder Operator besitzt. Je höher die Priorität, umso eher wird der Operator ausgeführt.

Bezeichnung	Operatorsymbol	Priorität	Bewertungsreihenfolge
Klammern	() []	14	Von links nach rechts
Komponentenauswahl	. ->	14	Von links nach rechts
Arithmetische Negation	-	13	Von rechts nach links
Logische Negation	!	13	Von rechts nach links
Bitlogische Negation	~	13	Von rechts nach links
Inkrement	++	13	Von rechts nach links
Dekrement	--	13	Von rechts nach links
Arithmetische Operatoren	* / %	12	Von links nach rechts
	+ -	11	Von links nach rechts
Shift-Operatoren	<< >>	10	Von links nach rechts
Vergleichsoperatoren	> >= < <=	9	Von links nach rechts
	== !=	8	Von links nach rechts
Bit-Operatoren	&	7	Von links nach rechts
	^	6	Von links nach rechts
	\|	5	Von links nach rechts
Logische Operatoren	&&	4	Von links nach rechts
	\|\|	3	Von links nach rechts
Zuweisungsoperatoren	= += -= *= /= %= >>= <<= &= ^= \|=	2	Von rechts nach links
Sequenzoperator	,	1	Von rechts nach links

Stehen mehrere Operatoren mit gleicher Priorität hintereinander, so erfolgt die Auswertungsreihenfolge der Reihe nach - entweder von links nach rechts oder von rechts nach links. Auch hier hilft nur der Blick in die Präzedenz-Tabelle. Über den Daumen gepeilt gilt: Binäre Operatoren werden von links nach rechts ausgeführt, unäre Operatoren von rechts nach links.

Die höchste Priorität haben Klammern. Das bedeutet, durch entsprechende Klammerung können wir jederzeit die Auswertungsreihenfolge von Operatoren ändern. Setze die Klammern auch dann, wenn Du nicht sicher bist, ob die verwendeten Operatoren tatsächlich in der gewünschten Reihenfolge ausgeführt werden. Die Klammern schaden nicht, erzwingen aber die Ausführungsreihenfolge.

Datei: Quelldateien/main.cpp

#include <iostream> // std::cout, std::endl, std::cin
#include <stdlib.h> // EXIT_SUCCESS
 
int main(void)
{
	bool a, b, c, r;
	a = false;
	b = true;
	c = true;
	r = (a && b) != c;
	std::cout << r << std::endl;
 
        std::cin.get();
        return EXIT_SUCCESS;
}

Das Ergebnis ist true.

Kommentare zu diesem Beitrag

Sie müssen angemeldet sein, um eine Nachricht zu erstellen. Anmelden »