Ganzzahl-Literal

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

C++ Sprache

Allgemeine Themen
Präprozessor Kommentare	Schlüsselwörter Escape-Sequenzen
Kontrollfluss
Bedingte Ausführungsaussagen
if	switch
Iterationsanweisungen (Schleifen)
for Bereichs-for (C++11)	while do-while
Sprunganweisungen
continue - break	goto - return
Funktionen
Funktionsdeklaration
Lambda-Funktionsausdruck
inline-Spezifizierer
Dynamische Ausnahmespezifikationen (bis C++17*)
noexcept-Spezifizierer (C++11)
Ausnahmen
throw-Ausdruck try-Block	catch-Handler
Namensräume
Namensdeklaration	Namensaliase
Typen
Fundamentale Typen Aufzählungstypen Funktionstypen	Klassen-/Strukturtypen Union-Typen
Spezifizierer
const/volatile decltype (C++11) auto (C++11)	constexpr (C++11) consteval (C++20) constinit (C++20)
Speicherdauer-Spezifizierer
Initialisierung
Standardinitialisierung Wertinitialisierung Nullinitialisierung Kopierinitialisierung Direkte Initialisierung	Aggregatinitialisierung Listeninitialisierung (C++11)   Konstante Initialisierung Referenzinitialisierung

Ausdrücke
Wertkategorien Reihenfolge der Auswertung	Operatoren Operatorrangfolge
Alternative Darstellungen
Literale
Boolesch - Ganzzahl - Gleitkomma
Zeichen - String - nullptr (C++11)
Benutzerdefinierte (C++11)
Dienstprogramme
Attribute (C++11)
Typen
typedef-Deklaration
Typalias-Deklaration (C++11)
Umwandlungen
Implizite Konvertierungen static_cast const_cast	Explizite Konvertierungen dynamic_cast reinterpret_cast
Speicherzuweisung
new-Ausdruck	delete-Ausdruck
Klassen
Klassendeklaration Konstruktoren this-Zeiger	Zugriffsspezifizierer friend-Spezifizierer
Klassenspezifische Funktionseigenschaften
Virtuelle Funktion override-Spezifizierer (C++11)   final-Spezifizierer (C++11)	explicit (C++11) static
Spezielle Member-Funktionen
Standardkonstruktor Kopierkonstruktor Move-Konstruktor (C++11)	Kopierzuweisung Move-Zuweisung (C++11) Destruktor
Templates
Klassenschablone Funktionsschablone	Schablonenspezialisierung Parameter-Pakete (C++11)
Sonstiges
Inline-Assembler	Geschichte von C++

 

Ausdrücke

Allgemein
Wertkategorien Reihenfolge der Auswertung Konstante Ausdrücke Primärausdrücke	Lambda-Ausdrücke (C++11) Requires-Ausdrücke (C++20) Pack-Indizierungs-Ausdruck (C++26) Potenziell ausgewertete Ausdrücke
Literale
Ganzzahl-Literale Gleitkomma-Literale Boolesche Literale Zeichen-Literale	Escape-Sequenzen Zeichenketten-Literale Null-Zeiger-Literal (C++11) Benutzerdefinierte Literale (C++11)
Operatoren
Zuweisungsoperatoren Inkrement und Dekrement Arithmetische Operatoren Logische Operatoren Vergleichsoperatoren Member-Zugriffsoperatoren Andere Operatoren new-Ausdruck delete-Ausdruck throw-Ausdruck	alignof sizeof sizeof... (C++11) typeid noexcept (C++11) Falt-Ausdrücke (C++17) Alternative Darstellungen von Operatoren Priorität und Assoziativität Operatorüberladung Standardvergleiche (C++20)
Konvertierungen
Implizite Konvertierungen Explizite Konvertierungen Übliche arithmetische Konvertierungen     Benutzerdefinierte Konvertierung	const_cast static_cast dynamic_cast reinterpret_cast

 

Ermöglicht die direkte Verwendung von Werten vom Ganzzahltyp in Ausdrücken.

Syntax

Ein Ganzzahl-Literal hat die Form

dezimal-literal integer-suffix (optional)	(1)
oktal-literal integer-suffix (optional)	(2)
hex-literal integer-suffix (optional)	(3)
binär-literal integer-suffix (optional)	(4)	(seit C++14)

wobei

• dezimal-literal ist eine von Null verschiedene Dezimalziffer (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)
• oktal-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 mehreren Hexadezimalziffern (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F)
• binär-literal ist die Zeichenfolge 0b oder die Zeichenfolge 0B, gefolgt von einer oder mehreren Binärziffern (0, 1)
• integer-suffix, falls vorhanden, kann eines oder beide der folgenden enthalten (falls beide vorhanden sind, können sie in beliebiger Reihenfolge erscheinen)

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

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

long-long-suffix (die Zeichenfolge ll oder die Zeichenfolge LL)

(seit C++11)

size-suffix (das Zeichen z oder das Zeichen Z)

(seit C++23)

Optionale einfache Anführungszeichen (') können zwischen die Ziffern als Trennzeichen eingefügt werden; sie werden bei der Bestimmung des Werts des Literals ignoriert.

(seit C++14)

Ein Ganzzahl-Literal (wie jedes Literal) ist ein primärer Ausdruck.

Erklärung

1) Dezimales Ganzzahl-Literal (Basis 10).

2) Oktales Ganzzahl-Literal (Basis 8).

3) Hexadezimales Ganzzahl-Literal (Basis 16, die Buchstaben 'a' bis 'f' stellen die Werte (dezimal) 10 bis 15 dar).

4) Binäres Ganzzahl-Literal (Basis 2).

Die erste Ziffer eines Ganzzahl-Literals ist die höchstwertige.

Beispiel. Die folgenden Variablen werden mit demselben 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 Ganzzahl-Literals ist der erste Typ, in den der Wert passt, aus der Liste der Typen, die vom verwendeten numerischen Basis und dem verwendeten integer-suffix abhängen

Suffix	Dezimale Basen	Binäre, Oktal- oder Hexadezimalbasen
(kein Suffix)	int long int long long int (seit C++11)	int unsigned int long int unsigned long int long long int (seit C++11) unsigned long long int (seit C++11)
u oder U	unsigned int unsigned long int unsigned long long int (seit C++11)	unsigned int unsigned long int unsigned long long int (seit C++11)
l oder L	long int unsigned long int (bis C++11) long long int (seit C++11)	long int unsigned long int long long int (seit C++11) unsigned long long int (seit C++11)
beide l/L und u/U	unsigned long int unsigned long long int (seit C++11)	unsigned long int unsigned long long int (seit C++11)
ll oder LL	long long int (seit C++11)	long long int (seit C++11) unsigned long long int (seit C++11)
beide ll/LL und u/U	unsigned long long int (seit C++11)	unsigned long long int (seit C++11)
z oder Z	die vorzeichenbehaftete Version von std::size_t (seit C++23)	die vorzeichenbehaftete Version von std::size_t (seit C++23) std::size_t (seit C++23)
beide z/Z und u/U	std::size_t (seit C++23)	std::size_t (seit C++23)

Wenn der Wert des Ganzzahl-Literals das keinen size-suffix hat(seit C++23) zu groß ist, um in einen der durch Suffix/Basis-Kombination erlaubten Typen zu passen, und der Compiler einen erweiterten Ganzzahltyp (wie __int128) unterstützt, der den Wert des Literals darstellen kann, kann dem Literal dieser erweiterte Ganzzahltyp zugewiesen werden – andernfalls ist das Programm ungültig.

Hinweise

Buchstaben in Ganzzahl-Literalen sind nicht case-sensitiv: 0xDeAdBeEfU und 0XdeadBEEFu stellen dieselbe Zahl dar (eine Ausnahme ist der long-long-suffix, der entweder ll oder LL ist, niemals lL oder Ll)(seit C++11).

Es gibt keine negativen Ganzzahl-Literale. Ausdrücke wie -1 wenden den unären Minus-Operator auf den vom Literal dargestellten Wert an, was implizite Typkonvertierungen beinhalten kann.

In C vor C99 (aber nicht in C++) dürfen unsuffigierte Dezimalwerte, die nicht in long int passen, den Typ unsigned long int haben.

Bei Verwendung in einem steuernden Ausdruck von #if oder #elif verhalten sich alle vorzeichenbehafteten Ganzzahlkonstanten so, als hätten sie den Typ std::intmax_t und alle vorzeichenlosen Ganzzahlkonstanten verhalten sich so, als hätten sie den Typ std::uintmax_t.

(seit C++11)

Aufgrund des maximalen Munch müssen Hexadezimal-Ganzzahl-Literale, die auf e und E enden, wenn sie von den Operatoren + oder - gefolgt werden, durch Whitespace oder Klammern im Quelltext vom Operator getrennt werden

auto x = 0xE+2.0;   // error
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 zu einem Fehler bei der weiteren Analyse führt.

Feature-Test-Makro	Wert	Std	Feature
__cpp_binary_literals	201304L	(C++14)	Binäre Literale
__cpp_size_t_suffix	202011L	(C++23)	Literal-Suffixe für std::size_t und seine vorzeichenbehaftete Version

Beispiel

Führen Sie diesen Code aus

#include <cstddef>
#include <iostream>
#include <type_traits>
 
int main()
{
    std::cout << 123 << '\n'
              << 0123 << '\n'
              << 0x123 << '\n'
              << 0b10 << '\n'
              << 12345678901234567890ull << '\n'
              << 12345678901234567890u << '\n'; // the type is unsigned long long
                                                // even without a long long suffix
 
//  std::cout << -9223372036854775808 << '\n'; // error: the value
               // 9223372036854775808 cannot fit in signed long long, which is the
               // biggest type allowed for unsuffixed decimal integer literal
    std::cout << -9223372036854775808u << '\n'; // unary minus applied to unsigned
               // value subtracts it from 2^64, this gives 9223372036854775808
    std::cout << -9223372036854775807 - 1 << '\n'; // correct way to calculate
                                                   // the value -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
}

Ausgabe

123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808

Fehlerberichte

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

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
CWG 2698	C++23	ein Ganzzahl-Literal mit size-suffix könnte einen erweiterten Ganzzahltyp haben	ungültig, wenn zu groß

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 5.13.2 Ganzzahl-Literale [lex.icon]

• C++20 Standard (ISO/IEC 14882:2020)

• 5.13.2 Ganzzahl-Literale [lex.icon]

• C++17 Standard (ISO/IEC 14882:2017)

• 5.13.2 Ganzzahl-Literale [lex.icon]

• C++14 Standard (ISO/IEC 14882:2014)

• 2.14.2 Ganzzahl-Literale [lex.icon]

• C++11 Standard (ISO/IEC 14882:2011)

• 2.14.2 Ganzzahl-Literale [lex.icon]

• C++98 Standard (ISO/IEC 14882:1998)

• 2.13.1 Ganzzahl-Literale [lex.icon]

Siehe auch

benutzerdefinierte Literale(C++11)	Literale mit benutzerdefiniertem Suffix
C-Dokumentation für Ganzzahlkonstante