Arithmetic operators

Gibt das Ergebnis der spezifischen arithmetischen Operation zurück.

Allgemeine Erklärung

Alle eingebauten arithmetischen Operatoren berechnen das Ergebnis einer spezifischen arithmetischen Operation und geben ihr Ergebnis zurück. Die Argumente werden nicht modifiziert.

Konvertierungen

Wenn der an einen eingebauten arithmetischen Operator übergebene Operand ein integraler oder unbegrenzter Aufzählungstyp ist, dann durchläuft der Operand vor jeder anderen Aktion (aber nach der Lvalue-zu-Rvalue-Konvertierung, falls zutreffend) Integral Promotion . Wenn ein Operand Array- oder Funktionstyp hat, werden Array-zu-Zeiger - und Funktion-zu-Zeiger -Konvertierungen angewendet.

Für die binären Operatoren (außer Verschiebungen), wenn die höhergestuften Operanden unterschiedliche Typen haben, übliche arithmetische Konvertierungen werden angewendet.

Überläufe

Die Arithmetik vorzeichenloser Ganzzahlen wird stets modulo 2 n
durchgeführt, wobei n die Anzahl der Bits in der jeweiligen Ganzzahl ist. Zum Beispiel ergibt für unsigned int das Addieren von eins zu UINT_MAX den Wert ​ 0 ​ , und das Subtrahieren von eins von ​ 0 ​ ergibt UINT_MAX .

Wenn eine Operation mit vorzeichenbehafteten Ganzzahlen überläuft (das Ergebnis passt nicht in den Ergebnistyp), ist das Verhalten undefiniert — die möglichen Ausprägungen einer solchen Operation umfassen:

• es umläuft gemäß den Regeln der Darstellung (typischerweise two's complement ),
• es löst eine Trap aus — auf einigen Plattformen oder aufgrund von Compiler-Optionen (z.B. -ftrapv in GCC und Clang),
• es sättigt zum Minimal- oder Maximalwert (auf vielen DSPs),
• es wird vollständig optimized out by the compiler .

Gleitkomma-Umgebung

Wenn #pragma STDC FENV_ACCESS unterstützt wird und auf ON gesetzt ist, befolgen alle Gleitkomma-Operatoren die aktuelle Rundungsrichtung und melden Gleitkomma-Arithmetikfehler wie in math_errhandling spezifiziert, es sei denn, sie sind Teil eines statischen Initialisierers (in diesem Fall werden keine Gleitkomma-Ausnahmen ausgelöst und der Rundungsmodus ist "zu nächstem").

Gleitkomma-Kontraktion

Sofern nicht #pragma STDC FP_CONTRACT unterstützt wird und auf OFF gesetzt ist, darf alle Gleitkommaarithmetik so ausgeführt werden, als ob die Zwischenergebnisse unendlichen Wertebereich und unendliche Genauigkeit hätten, das heißt, Optimierungen, die Rundungsfehler und Gleitkomma-Ausnahmen auslassen, sind erlaubt. Beispielsweise erlaubt C++ die Implementierung von ( x * y ) + z mit einer einzelnen fused multiply-add CPU-Instruktion oder die Optimierung von a = x * x * x * x ; zu tmp = x * x ; a = tmp * tmp .

Unabhängig von der Vertragsgestaltung können Zwischenergebnisse der Gleitkommaarithmetik einen Bereich und eine Genauigkeit aufweisen, die von der durch ihren Typ angegebenen abweichen, siehe FLT_EVAL_METHOD .

Formal macht der C++-Standard keine Zusicherung bezüglich der Genauigkeit von Gleitkommaoperationen.

Unäre arithmetische Operatoren

Die unären arithmetischen Operatorausdrücke haben die Form

Unäre + und - Operatoren haben eine höhere Präzedenz als alle binären arithmetischen Operatoren, daher kann der Ausdruck keine obersten binären arithmetischen Operatoren enthalten. Diese Operatoren assoziieren von rechts nach links:

+a - b; // entspricht (+a) - b, NICHT +(a - b)
-c + d; // entspricht (-c) + d, NICHT -(c + d)
+-e; // entspricht +(-e), das unäre + ist ein No-Op, wenn "e" ein eingebauter Typ ist
     // da jede mögliche Höherstufung bereits während der Negation durchgeführt wird

Eingebaute unäre arithmetische Operatoren

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jeden cv-unqualifizierten promoted arithmetischen Typ A und für jeden Typ T die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

#include <iostream>
int main()
{
    char c = 0x6a;
    int n1 = 1;
    unsigned char n2 = 1;
    unsigned int n3 = 1;
    std::cout << "char: " << c << " int: " << +c << "\n"
                 "-1, where 1 is signed: " << -n1 << "\n"
                 "-1, where 1 is unsigned char: " << -n2 << "\n"
                 "-1, where 1 is unsigned int: " << -n3 << '\n';
    char a[3];
    std::cout << "size of array: " << sizeof a << "\n"
                 "size of pointer: " << sizeof +a << '\n';
}

char: j int: 106
-1, where 1 is signed: -1
-1, where 1 is unsigned char: -1
-1, where 1 is unsigned int: 4294967295
size of array: 3
size of pointer: 8

Additive Operatoren

Die additiven Operatorausdrücke haben die Form

Die binären + - und - -Operatoren haben eine höhere Präzedenz als alle anderen binären arithmetischen Operatoren, außer * , / und % . Diese Operatoren assoziieren von links nach rechts:

a + b * c;  // entspricht a + (b * c),  NICHT (a + b) * c
d / e - f;  // entspricht (d / e) - f,  NICHT d / (e - f)
g + h >> i; // entspricht (g + h) >> i, NICHT g + (h >> i)
j - k + l - m; // entspricht ((j - k) + l) - m

Eingebaute additive Operatoren

Für eingebaute binäre Plus- und Minusoperatoren müssen sowohl lhs als auch rhs Prvalues sein, und eine der folgenden Bedingungen muss erfüllt sein:

• Beide Operanden haben arithmetischen oder unbegrenzten Aufzählungstyp. In diesem Fall werden usual arithmetic conversions auf beide Operanden angewendet.
• Genau ein Operand hat integralen oder unbegrenzten Aufzählungstyp. In diesem Fall wird integral promotion auf diesen Operanden angewendet.

In der verbleibenden Beschreibung in diesem Abschnitt beziehen sich "Operand(en)", lhs und rhs auf die konvertierten oder heraufgestuften Operanden.

Wenn beide Operanden einen Gleitkommatyp haben und der Typ IEEE-Gleitkommaarithmetik unterstützt (siehe std::numeric_limits::is_iec559 ):

• Wenn ein Operand NaN ist, ist das Ergebnis NaN.
• Unendlich minus Unendlich ist NaN, und FE_INVALID wird ausgelöst.
• Unendlich plus negativ Unendlich ist NaN, und FE_INVALID wird ausgelöst.

Zeigerarithmetik

Wenn ein Ausdruck J mit ganzzahligem Typ zu einem Ausdruck P mit Zeigertyp addiert oder von diesem subtrahiert wird, hat das Ergebnis den Typ von P .

• Wenn P zu einem Null-Zeigerwert ausgewertet wird und J zu ​ 0 ​ ausgewertet wird, ist das Ergebnis ein Null-Zeigerwert.
• Andernfalls, wenn P auf das i -te Element eines Array-Objekts x mit n Elementen zeigt, und der Wert von J als j gegeben ist, wird P wie folgt addiert oder subtrahiert:

• Die Ausdrücke P + J und J + P

• zeigen auf das i+j -te Element von x , falls i + j in [ ​ 0 ​ , n ) liegt, und
• sind Zeiger hinter das letzte Element von x , falls i + j gleich n ist.

• Der Ausdruck P - J

• zeigt auf das i-j -te Element von x , falls i - j in [ ​ 0 ​ , n ) liegt, und
• ist ein Zeiger hinter das letzte Element von x , falls i - j gleich n ist.

• Andere j -Werte führen zu undefiniertem Verhalten.

• Andernfalls, wenn P auf ein vollständiges Objekt, ein Basisklassen-Subobjekt oder ein Member-Subobjekt y zeigt, und der Wert von J als j gegeben ist, wird P wie folgt addiert oder subtrahiert:

• Die Ausdrücke P + J und J + P

• zeigen auf y wenn j gleich ​ 0 ​ ist, und
• sind Zeiger hinter das Ende von y wenn j gleich 1 ist.

• Der Ausdruck P - J

• zeigt auf y wenn j gleich ​ 0 ​ ist, und
• ist ein Zeiger hinter das Ende von y wenn j gleich - 1 ist.

• Andere j -Werte führen zu undefiniertem Verhalten.

• Andernfalls, wenn P ein Zeiger hinter das Ende eines Objekts z ist, mit dem Wert von J als j :

• Falls z ein Array-Objekt mit n Elementen ist, wird P wie folgt addiert oder subtrahiert:

• Die Ausdrücke P + J und J + P

• zeigen auf das n+j -te Element von z , falls n + j in [ ​ 0 ​ , n ) liegt, und
• sind Zeiger hinter das letzte Element von z , falls j gleich ​ 0 ​ ist.

• Der Ausdruck P - J

• zeigt auf das n-j -te Element von z , falls n - j in [ ​ 0 ​ , n ) liegt, und
• ist ein Zeiger hinter das letzte Element von z , falls j gleich ​ 0 ​ ist.

• Andere j -Werte führen zu undefiniertem Verhalten.

• Andernfalls wird P wie folgt addiert oder subtrahiert:

• Die Ausdrücke P + J und J + P

• zeigen auf z , falls j gleich - 1 ist, und
• sind Zeiger hinter das Ende von z , falls j gleich ​ 0 ​ ist.

• Der Ausdruck P - J

• zeigt auf z , falls j gleich 1 ist, und
• ist ein Zeiger hinter das Ende von z , falls j gleich ​ 0 ​ ist.

• Andere j -Werte führen zu undefiniertem Verhalten.

• Andernfalls ist das Verhalten undefiniert.

Wenn zwei Zeigerausdrücke P und Q voneinander subtrahiert werden, ist der Typ des Ergebnisses std::ptrdiff_t .

• Wenn P und Q beide zu Null-Zeigerwerten ausgewertet werden, ist das Ergebnis ​ 0 ​ .
• Andernfalls, wenn P und Q jeweils auf das i -te und j -te Array-Element desselben Array-Objekts x zeigen, hat der Ausdruck P - Q den Wert i − j .

• Wenn i − j nicht durch std::ptrdiff_t darstellbar ist, ist das Verhalten undefiniert.

• Andernfalls, wenn P und Q auf dasselbe vollständige Objekt, Basisklassen-Subobjekt oder Mitglieds-Subobjekt zeigen, ist das Ergebnis ​ 0 ​ .
• Andernfalls ist das Verhalten undefiniert.

Diese Zeigerarithmetik-Operatoren ermöglichen es Zeigern, die LegacyRandomAccessIterator Anforderungen zu erfüllen.

Für Addition und Subtraktion, wenn P oder Q den Typ "Zeiger auf (möglicherweise cv-qualifiziertes) T " haben, wobei T und der Array-Elementtyp nicht ähnlich sind, ist das Verhalten undefiniert:

int arr[5] = {1, 2, 3, 4, 5};
unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1);
unsigned int k = *p; // OK, der Wert von "k" ist 2
unsigned int *q = p + 1; // undefiniertes Verhalten: "p" zeigt auf int, nicht unsigned int

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jedes Paar von heraufgestuften arithmetischen Typen L und R und für jeden Objekttyp T die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

wobei LR das Ergebnis der üblichen arithmetischen Konvertierungen auf L und R ist.

#include <iostream>
int main()
{
    char c = 2;
    unsigned int un = 2;
    int n = -10;
    std::cout << " 2 + (-10), where 2 is a char    = " << c + n << "\n"
                 " 2 + (-10), where 2 is unsigned  = " << un + n << "\n"
                 " -10 - 2.12  = " << n - 2.12 << '\n';
    char a[4] = {'a', 'b', 'c', 'd'};
    char* p = &a[1];
    std::cout << "Pointer addition examples: " << *p << *(p + 2)
              << *(2 + p) << *(p - 1) << '\n';
    char* p2 = &a[4];
    std::cout << "Pointer difference: " << p2 - p << '\n';
}

 2 + (-10), where 2 is a char    = -8
 2 + (-10), where 2 is unsigned  = 4294967288
 -10 - 2.12  = -12.12
Pointer addition examples: bdda
Pointer difference: 3

Multiplikative Operatoren

Die multiplikativen Operatorausdrücke haben die Form

Multiplikative Operatoren haben eine höhere Präzedenz als alle anderen binären arithmetischen Operatoren. Diese Operatoren assoziieren von links nach rechts:

a + b * c;  // entspricht a + (b * c),  NICHT (a + b) * c
d / e - f;  // entspricht (d / e) - f,  NICHT d / (e - f)
g % h >> i; // entspricht (g % h) >> i, NICHT g % (h >> i)
j * k / l % m; // entspricht ((j * k) / l) % m

Eingebaute multiplikative Operatoren

Für die eingebauten Multiplikations- und Divisionsoperatoren müssen beide Operanden arithmetischen oder unbegrenzten Aufzählungstyp haben. Für den eingebauten Restoperator müssen beide Operanden ganzzahligen oder unbegrenzten Aufzählungstyp haben. Übliche arithmetische Konvertierungen werden auf beide Operanden angewendet.

In der verbleibenden Beschreibung in diesem Abschnitt beziehen sich "Operand(en)", lhs und rhs auf die konvertierten Operand(en).

Hinweis: Bis zur Lösung von CWG Issue 614 ( N2757 ) war das Vorzeichen des Restes bei binärem Operator % implementierungsdefiniert, wenn ein oder beide Operanden negativ waren, da es von der Rundungsrichtung der Ganzzahldivision abhängt. Die Funktion std::div bot in diesem Fall wohldefiniertes Verhalten.

Hinweis: Für Gleitkomma-Rest siehe std::remainder und std::fmod .

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jedes Paar von heraufgestuften arithmetischen Typen LA und RA sowie für jedes Paar von heraufgestuften integralen Typen LI und RI die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

wobei LRx das Ergebnis der üblichen arithmetischen Konvertierungen auf Lx und Rx ist.

#include <iostream>
int main()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout << "2 * (-10), where 2 is a char    = " << c * n << "\n"
                 "2 * (-10), where 2 is unsigned  = " << un * n << "\n"
                 "-10 / 2.12  = " << n / 2.12 << "\n"
                 "-10 / 21  = " << n / 21 << "\n"
                 "-10 % 21  = " << n % 21 << '\n';
}

2 * (-10), where 2 is a char    = -20
2 * (-10), where 2 is unsigned  = 4294967276
-10 / 2.12  = -4.71698
-10 / 21  = 0
-10 % 21  = -10

Bitweise Logikoperatoren

Die bitweisen logischen Operatorausdrücke haben die Form

Der bitweise NOT-Operator hat eine höhere Präzedenz als alle binären arithmetischen Operatoren. Er assoziiert von rechts nach links:

~a - b; // entspricht (~a) - b, NICHT ~(a - b)
~c * d; // entspricht (~c) * d, NICHT ~(c * d)
~-e; // entspricht ~(-e)

Es gibt eine Mehrdeutigkeit in der Grammatik, wenn ~ von einem Typnamen oder einem decltype -Spezifizierer (seit C++11) gefolgt wird: Es kann sich entweder um operator~ handeln oder um den Beginn eines Destruktor -Identifikators. Die Mehrdeutigkeit wird aufgelöst, indem ~ als operator~ behandelt wird. ~ kann nur an Stellen einen Destruktor-Identifikator beginnen, an denen die Bildung eines operator~ syntaktisch ungültig ist.

Alle anderen bitweisen Logikoperatoren haben eine niedrigere Präzedenz als alle anderen binären arithmetischen Operatoren. Bitweises UND hat eine höhere Präzedenz als bitweises XOR, welches eine höhere Präzedenz als bitweises ODER hat. Sie assoziieren von links nach rechts:

a & b * c;  // entspricht a & (b * c),  NICHT (a & b) * c
d / e ^ f;  // entspricht (d / e) ^ f,  NICHT d / (e ^ f)
g << h | i; // entspricht (g << h) | i, NICHT g << (h | i)
j & k & l; // entspricht (j & k) & l
m | n ^ o  // entspricht m | (n ^ o)

Eingebaute bitweise Logikoperatoren

Für den eingebauten bitweisen NOT-Operator muss rhs ein Prvalue von integralem oder unbegrenztem Aufzählungstyp sein, und es wird eine integrale Promotion auf rhs durchgeführt. Für andere eingebaute bitweise Logikoperatoren müssen beide Operanden integralen oder unbegrenzten Aufzählungstyp haben, und es werden übliche arithmetische Konvertierungen auf beide Operanden angewendet.

In der verbleibenden Beschreibung in diesem Abschnitt beziehen sich "Operand(en)", lhs und rhs auf die konvertierten oder heraufgestuften Operanden.

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jedes Paar von heraufgestuften Ganzzahltypen L und R die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

wobei LR das Ergebnis der üblichen arithmetischen Konvertierungen auf L und R ist.

#include <bitset>
#include <cstdint>
#include <iomanip>
#include <iostream>
int main()
{
    std::uint16_t mask = 0x00f0;
    std::uint32_t x0 = 0x12345678;
    std::uint32_t x1 = x0 | mask;
    std::uint32_t x2 = x0 & ~mask;
    std::uint32_t x3 = x0 & mask;
    std::uint32_t x4 = x0 ^ mask;
    std::uint32_t x5 = ~x0;
    using bin16 = std::bitset<16>;
    using bin32 = std::bitset<32>;
    std::cout << std::hex << std::showbase
              << "Maske: " << mask << std::setw(49) << bin16(mask) << "\n"
                 "Wert: " << x0 << std::setw(42) << bin32(x0) << "\n"
                 "Bits setzen: " << x1 << std::setw(35) << bin32(x1) << "\n"
                 "Bits löschen: " << x2 << std::setw(34) << bin32(x2) << "\n"
                 "Bits auswählen: " << x3 << std::setw(39) << bin32(x3) << "\n"
                 "Bits XOR-en: " << x4 << std::setw(35) << bin32(x4) << "\n"
                 "Bits invertieren: " << x5 << std::setw(33) << bin32(x5) << '\n';
}

Maske: 0xf0                                 0000000011110000
Wert: 0x12345678          00010010001101000101011001111000
Bits setzen: 0x123456f8   00010010001101000101011011111000
Bits löschen: 0x12345608  00010010001101000101011000001000
Bits auswählen: 0x70       00000000000000000000000001110000
Bits XOR-en: 0x12345688   00010010001101000101011010001000
Bits invertieren: 0xedcba987 11101101110010111010100110000111

Bitweise Schiebeoperatoren

Die bitweisen Schiebeoperator-Ausdrücke haben die Form

Bitweise Verschiebeoperatoren haben eine höhere Präzedenz als bitweise Logikoperatoren, aber eine niedrigere Präzedenz als additive und multiplikative Operatoren. Diese Operatoren assoziieren von links nach rechts:

a >> b * c;  // entspricht a >> (b * c),  NICHT (a >> b) * c
d << e & f;  // entspricht (d << e) & f,  NICHT d << (e & f)
g << h >> i; // entspricht (g << h) >> i, NICHT g << (h >> i)

Eingebaute bitweise Verschiebeoperatoren

Für die eingebauten bitweisen Verschiebeoperatoren müssen beide Operanden Prvalues von ganzzahligen oder unbegrenzten Aufzählungstypen sein. Ganzzahlige Höherstufungen werden auf beiden Operanden durchgeführt.

In der verbleibenden Beschreibung in diesem Abschnitt beziehen sich "Operand(en)", a , b , lhs und rhs auf die konvertierten oder heraufgestuften Operanden.

Wenn der Wert von rhs negativ ist oder nicht kleiner als die Anzahl der Bits in lhs ist, ist das Verhalten undefiniert.

Der Typ des Ergebnisses ist der von lhs .

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jedes Paar von heraufgestuften Ganzzahltypen L und R die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

#include <iostream>
enum { ONE = 1, TWO = 2 };
int main()
{
    std::cout << std::hex << std::showbase;
    char c = 0x10;
    unsigned long long ull = 0x123;
    std::cout << "0x123 << 1 = " << (ull << 1) << "\n"
                 "0x123 << 63 = " << (ull << 63) << "\n" // Überlauf bei unsigned
                 "0x10 << 10 = " << (c << 10) << '\n';   // char wird zu int heraufgestuft
    long long ll = -1000;
    std::cout << std::dec << "-1000 >> 1 = " << (ll >> ONE) << '\n';
}

0x123 << 1 = 0x246
0x123 << 63 = 0x8000000000000000
0x10 << 10 = 0x4000
-1000 >> 1 = -500

Standardbibliothek

Arithmetische Operatoren sind für viele Standardbibliothek-Typen überladen.

Unäre arithmetische Operatoren

Additive Operatoren

Multiplikative Operatoren

Bitweise logische Operatoren

Bitweise Schiebeoperatoren

Stream-Einfüge-/Extraktionsoperatoren

In der gesamten Standardbibliothek werden bitweise Schiebeoperatoren häufig mit E/A-Streams ( std:: ios_base & oder einer der davon abgeleiteten Klassen) als linker Operand und Rückgabetyp überladen. Solche Operatoren werden als Stream-Einfügeoperatoren und Stream-Extraktionsoperatoren bezeichnet:

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

Operator-Präzedenz

Operatorüberladung