Integer literal

Ermöglicht die direkte Verwendung von Werten des Integer-Typs in Ausdrücken.

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 ganzzahligen Literals ist der erste Typ, in den der Wert passt, aus der Liste der Typen, die davon abhängt, welche numerische Basis und welches integer-suffix verwendet wurde:

Wenn der Wert des ganzzahligen Literals das keinen size-suffix besitzt (seit C++23) zu groß ist, um in einen der durch Suffix/Basis-Kombination erlaubten Typen zu passen, und der Compiler einen erweiterten Ganzzahltyp unterstützt (wie __int128 ), der den Wert des Literals darstellen kann, kann dem Literal dieser erweiterte Ganzzahltyp zugewiesen werden — 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