C++ Operatoren

Einführung

In diesem Lab lernst du, wie du in C++ Operatoren verwendest. Du wirst lernen, wie du arithmetische Operatoren, relationale Operatoren, logische Operatoren und bitweise Operatoren verwendest.

Inhaltsvorschau

Für grundlegende numerische und logische Daten verwenden wir Operatoren, um mit ihnen zu operieren. Wie in anderen Sprachen bietet C++ umfassende Unterstützung für Operatoren. Lernen Sie sie jetzt kennen.

• Arithmetische Operationen
• Operationen mit gemischten Datentypen
• Zuweisungsoperatoren mit zusammengesetzter Wirkung
• Typumwandlung
• Relationale und logische Operatoren

Arithmetische Operationen

C++ unterstützt die folgenden arithmetischen Operatoren für Zahlen:

Alle oben genannten Operatoren sind binäre Operatoren, die zwei Operanden akzeptieren. Die Multiplikation, Division und der Modulo-Operator haben eine höhere Präzedenz als die Addition und Subtraktion.

Es ist wichtig zu beachten, dass int/int ein int ergibt, wobei das Ergebnis abgeschnitten wird, 1/2 → 0 (nicht 0.5).

Operationen mit gemischten Datentypen

Wenn beide Operanden einer arithmetischen Operation denselben Datentyp haben, wird die Operation in diesem Typ durchgeführt und das Ergebnis hat diesen Typ. Wenn die beiden Operanden jedoch unterschiedlichen Datentypen haben, wird der Compiler den Wert des kleineren Typs in den größeren Typ umwandeln (bekannt als implizite Typumwandlung). Die Operation wird dann im größeren Typ durchgeführt.

Beispiel

/* Testing mix-type arithmetic operations */
#include <iostream>
#include <iomanip>   // needed for formatting floating-point numbers
using namespace std;

int main() {
   int i1 = 2, i2 = 4;
   double d1 = 2.5, d2 = 5.0;

   // floating-points in fixed format with 1 decimal place
   cout<<fixed<<setprecision(1);

   cout << i1 << " + " << i2 << " = " << i1+i2 << endl;  // 6
   cout << d1 << " + " << d2 << " = " << d1+d2 << endl;  // 7.5
   cout << i1 << " + " << d2 << " = " << i1+d2 << endl;  // 7.0  <==

   cout << i1 << " - " << i2 << " = " << i1-i2 << endl;  // -2
   cout << d1 << " - " << d2 << " = " << d1-d2 << endl;  // -2.5
   cout << i1 << " - " << d2 << " = " << i1-d2 << endl;  // -3.0 <==

   cout << i1 << " * " << i2 << " = " << i1*i2 << endl;  // 8
   cout << d1 << " * " << d2 << " = " << d1*d2 << endl;  // 12.5
   cout << i1 << " * " << d2 << " = " << i1*d2 << endl;  // 10.0 <==

   cout << i1 << " / " << i2 << " = " << i1/i2 << endl;  // 0    <==
   cout << d1 << " / " << d2 << " = " << d1/d2 << endl;  // 0.5
   cout << i1 << " / " << d2 << " = " << i1/d2 << endl;  // 0.4  <==
   return 0;
}

Ausgabe:

2 + 4 = 6
2.5 + 5.0 = 7.5
2 + 5.0 = 7.0
2 - 4 = -2
2.5 - 5.0 = -2.5
2 - 5.0 = -3.0
2 * 4 = 8
2.5 * 5.0 = 12.5
2 * 5.0 = 10.0
2 / 4 = 0
2.5 / 5.0 = 0.5

Überlauf / Unterlauf

// Range of int is [-2147483648, 2147483647]
   int i1 = 2147483647;      // max int
   cout << i1 + 1 << endl;   // -2147483648 (overflow)
   cout << i1 * i1 << endl;  // 1

   int i2 = -2147483648;     // min int
   cout << i2 - 1 << endl;   // 2147483647 (underflow)
   cout << i2 * i2 << endl;  // 0

Bei arithmetischen Operationen wird der resultierende Wert, wenn er seinen Bereich überschreitet, umgewandelt. Die C++ Laufzeit gibt keine Fehler- oder Warnmeldung aus, sondern liefert ein falsches Ergebnis. Es ist wichtig zu beachten, dass das Überprüfen auf Überlauf/Unterlauf die Verantwortung des Programmierers ist.

Zuweisungsoperatoren mit zusammengesetzter Wirkung

C++ bietet auch die sogenannten Zuweisungsoperatoren mit zusammengesetzter Wirkung, wie folgt aufgelistet:

x = 5;
cout << x++ << endl;  // Save x (5); Increment x (=6); Print old x (5).
x = 5;
cout << ++x << endl;  // Increment x (=6); Print x (6).

Implizite Typumwandlung vs. Explizite Typumwandlung

Wenn Sie einen Wert eines grundlegenden (eingebauten) Typs an eine Variable eines anderen grundlegenden Typs zuweisen, konvertiert C++ den Wert automatisch in den empfangenden Typ, wenn die beiden Typen kompatibel sind. Beispielsweise:

• Wenn Sie einen int-Wert an eine double-Variable zuweisen, castet der Compiler den int-Wert automatisch in einen double-Wert (z.B. von 1 zu 1.0) und weist ihn der double-Variable zu.
• Wenn Sie einen double-Wert an eine int-Variable zuweisen, castet der Compiler den double-Wert automatisch in einen int-Wert (z.B. von 1.2 zu 1) und weist ihn der int-Variable zu. Der Bruchteil wird abgeschnitten und verloren. Einige Compiler geben eine Warnung/Fehlermeldung "mögliche Genauigkeitsverlust" aus; andere nicht.

 int i;
 double d;

 i = 3;
 d = i;    // Weist einen int-Wert an double zu
 cout << "d = " << d << endl;  // 3.0

 d = 5.5;
 i = d;    // Weist einen double-Wert an int zu
 cout << "i = " << i << endl;  // 5 (abgeschnitten, keine Warnung!)

Sie können explizit eine Typumwandlung durch den sogenannten einstelligen Typumwandlungsoperator in der Form (neuer-Typ) Operand oder neuer-Typ (Operand) durchführen. Der Typumwandlungsoperator nimmt einen Operanden im bestimmten Typ und gibt einen äquivalenten Wert im neuen Typ zurück. Beachten Sie, dass es eine Operation ist, die einen resultierenden Wert liefert, ähnlich einer Additionsoperation, obwohl die Addition zwei Operanden umfasst. Beispielsweise:

cout << (double)5 << endl;  // int 5 → double 5.0
cout << (int)5.5 << endl;   // double 5.5 → int 5

double aDouble = 5.6;
int anInt = (int)aDouble; // Gibt 5 zurück und weist anInt zu. aDouble ändert sich nicht!

// C++ unterstützt auch die funktionale Typumwandlung.
cout << double(5) << endl;     // 5.0
cout << int(5.5) << endl;      // 5
cout << int(aDouble) << endl;  // 5

Relationale und logische Operatoren

Oft müssen Sie zwei Werte vergleichen, bevor Sie eine Aktion ausführen. C++ bietet sechs Vergleichsoperatoren (oder relationale Operatoren):

Die Wahrheitstabellen lauten wie folgt:

// Gibt true zurück, wenn x zwischen 0 und 100 (einschließlich) liegt
(x >= 0) && (x <= 100)
// Falsch: 0 <= x <= 100 zu verwenden

// Gibt true zurück, wenn x außerhalb von 0 und 100 (einschließlich) liegt
(x < 0) || (x > 100)   //oder
!((x >= 0) && (x <= 100))

// Gibt true zurück, wenn year ein Schaltjahr ist
// Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100, oder wenn es durch 400 teilbar ist.
((year % 4 == 0) && (year % 100!= 0)) || (year % 400 == 0)

Zusammenfassung

Dieser Teil ist relativ einfach. Sie sollten ihn mit dem vorherigen Abschnitt in Beziehung setzen. Es ist nicht erforderlich, ihn auswendig zu lernen, sondern Sie sollten sich dessen Logik im Kopf vergegenwärtigen.