Integer literal

• 1 Syntax
• 2 Erklärung
• 3 Der Typ des Literals
• 4 Hinweise
• 5 Beispiel
• 6 Fehlerberichte
• 7 Referenzen
• 8 Siehe auch

Syntax

Ein Ganzzahlliteral hat die Form

wo

• decimal-literal ist eine Dezimalziffer ungleich Null ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ), gefolgt von null oder mehr Dezimalziffern ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )
• octal-literal ist die Ziffer Null ( 0 ) gefolgt von null oder mehr Oktalziffern ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 )
• hex-literal ist die Zeichenfolge 0x oder die Zeichenfolge 0X gefolgt von einer oder mehr Hexadezimalziffern ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , a , A , b , B , c , C , d , D , e , E , f , F )
• binary-literal ist die Zeichenfolge 0b oder die Zeichenfolge 0B gefolgt von einer oder mehr Binärziffern ( 0 , 1 )
• integer-suffix , falls angegeben, kann einen oder beide der folgenden Werte enthalten (falls beide angegeben sind, können sie in beliebiger Reihenfolge erscheinen):

• unsigned-suffix (das Zeichen u oder das Zeichen U )
• eines von

• long-suffix (das Zeichen l oder das Zeichen L )

Ein Integer-Literal (wie jedes Literal) ist ein primary expression .

Erklärung

Die erste Ziffer eines ganzzahligen Literals ist die signifikanteste.

Beispiel. Die folgenden Variablen werden mit dem gleichen Wert initialisiert:

int d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010; // C++14

Beispiel. Die folgenden Variablen werden ebenfalls mit demselben Wert initialisiert:

unsigned long long l1 = 18446744073709550592ull;       // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL;   // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU;   // C++14

Der Typ des Literals

Der Typ des Integer-Literals ist der erste Typ, in den der Wert passt, aus der Liste von Typen, die davon abhängt, welche Zahlenbasis und welches Integer-Suffix verwendet wurde:

Wenn der Wert des Integer-Literals das kein Size-Suffix(seit C++23) zu groß ist, um in einen der durch die Suffix/Basis-Kombination erlaubten Typen zu passen, und der Compiler einen erweiterten Integer-Typ (wie __int128) der den Wert des Literals darstellen kann, kann das Literal diesen erweiterten Integer-Typ erhalten, andernfalls ist das Programm fehlerhaft.

Hinweise

Die Buchstaben in den ganzzahligen Literalen sind unabhängig von der Groß- und Kleinschreibung: 0xDeAdBeEfU und 0XdeadBEEFu repräsentieren dieselbe Zahl (eine Ausnahme ist das long-long-suffix , welches entweder ll oder LL ist, niemals jedoch lL oder Ll ) (seit C++11) .

Es gibt keine negativen ganzzahligen Literale. Ausdrücke wie - 1 wenden den unären Minus-Operator auf den durch das Literal repräsentierten Wert an, was implizite Typkonvertierungen beinhalten kann.

In C vor C99 (aber nicht in C++) dürfen dezimale Werte ohne Suffix, die nicht in long int passen, den Typ unsigned long int haben.

Aufgrund von maximal munch müssen hexadezimale Ganzzahlliterale, die auf e oder E enden, wenn sie von den Operatoren + oder - gefolgt werden, im Quellcode durch Leerzeichen oder Klammern vom Operator getrennt werden:

auto x = 0xE+2.0;   // Fehler
auto y = 0xa+2.0;   // OK
auto z = 0xE +2.0;  // OK
auto q = (0xE)+2.0; // OK

Andernfalls wird ein einzelner ungültiger Präprozessor-Zahl-Token gebildet, was dazu führt, dass die weitere Analyse fehlschlägt.

Beispiel

#include <cstddef>
#include <iostream>
#include <type_traits>
int main()
{
    std::cout << 123 << '\n'
              << 0123 << '\n'
              << 0x123 << '\n'
              << 0b10 << '\n'
              << 12345678901234567890ull << '\n'
              << 12345678901234567890u << '\n'; // der Typ ist unsigned long long
                                                // selbst ohne long long-Suffix
//  std::cout << -9223372036854775808 << '\n'; // Fehler: der Wert
               // 9223372036854775808 passt nicht in signed long long, welches der
               // größte erlaubte Typ für dezimale Ganzzahlliterale ohne Suffix ist
    std::cout << -9223372036854775808u << '\n'; // unäres Minus angewendet auf unsigned
               // Wert subtrahiert ihn von 2^64, dies ergibt 9223372036854775808
    std::cout << -9223372036854775807 - 1 << '\n'; // korrekte Berechnung
                                                   // des Werts -9223372036854775808
#if __cpp_size_t_suffix >= 202011L // C++23
    static_assert(std::is_same_v<decltype(0UZ), std::size_t>);
    static_assert(std::is_same_v<decltype(0Z), std::make_signed_t<std::size_t>>);
#endif
}

123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808

Fehlerberichte

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

Referenzen

Siehe auch