Numerische, boolesche und Zeigerliterale

  • Artikel

Bei einem Literal handelt es sich um ein Programmelement, das direkt einen Wert darstellt. In diesem Artikel werden Literale vom Typ "Integer", "Gleitkomma", "Boolean" und "Zeiger" behandelt. Informationen zu Zeichenfolgen- und Zeichenliteralen finden Sie unter String and Character Literals (C++). Sie können auch eigene Literale basierend auf einer dieser Kategorien definieren. Weitere Informationen finden Sie unter User-defined literals (C++).

Sie können Literale in vielen Kontexten verwenden, aber am häufigsten zum Initialisieren von benannten Variablen und zum Weitergeben der Argumente an Funktionen:

const int answer = 42;      // integer literal
double d = sin(108.87);     // floating point literal passed to sin function
bool b = true;              // boolean literal
MyClass* mc = nullptr;      // pointer literal

In manchen Fällen ist es wichtig, dem Compiler darüber zu informieren, wie er ein Literal interpretieren soll oder welcher bestimmte Typ ihm erteilt werden soll. Sie erfolgt durch Anfügen von Präfixen oder Suffixen an das Literal. Beispielsweise weist das Präfix 0x dem Compiler an, die zahl zu interpretieren, die ihm als hexadezimaler Wert folgt, z. B 0x35. . . Das ULL Suffix weist den Compiler an, den Wert wie ein 5894345ULLTyp zu unsigned long long behandeln. In den folgenden Abschnitten finden Sie die vollständige Liste der Prä- und Suffixe für jeden Literaltyp.

Ganzzahlenliterale

Ganzzahlenliterale beginnen mit einer Ziffer und weisen weder Bruchteile noch Exponenten auf. Sie können ganzzahlige Literale in dezimaler, binärer, oktaler oder hexadezimaler Form angeben. Sie können optional ein ganzzahliges Literal als nicht signiert und als long- oder long-Typ mithilfe eines Suffixes angeben.

Wenn kein Präfix oder Suffix vorhanden ist, gibt der Compiler einen integralen Literalwerttyp int (32 Bit) an, wenn der Wert passt, andernfalls wird er typ long long (64 Bit) angegeben.

Starten Sie zum Angeben eines integralen Dezimalliterals die Spezifikation mit einer Ziffer ungleich 0. Beispiel:

int i = 157;        // Decimal literal
int j = 0198;       // Not a decimal number; erroneous octal literal
int k = 0365;       // Leading zero specifies octal literal, not decimal
int m = 36'000'000  // digit separators make large values more readable

Um ein oktales Integralliteral anzugeben, beginnen Sie die Angabe mit 0, gefolgt von einer Ziffernfolge im Bereich von 0 bis 7. Die Ziffern 8 und 9 sind Fehler, wenn sie ein oktales Literal angeben. Beispiel:

int i = 0377;   // Octal literal
int j = 0397;   // Error: 9 is not an octal digit

Um ein hexadezimales integrales Literal anzugeben, beginnen Sie mit 0x der Spezifikation oder 0X (der Fall des "x" spielt keine Rolle), gefolgt von einer Abfolge von Ziffern im Bereich 0 durch 9 und a (oder ) bis f (oder AF). Hexadezimalzahlen a (oder A) bis f (oder F) stellen Werte im Bereich von 10 bis 15 dar. Beispiel:

int i = 0x3fff;   // Hexadecimal literal
int j = 0X3FFF;   // Equal to i

Um einen nicht signierten Typ anzugeben, verwenden Sie entweder das Suffix oder U das u Suffix. Um einen langen Typ anzugeben, verwenden Sie entweder das Suffix oder L das l Suffix. Um einen integralen 64-Bit-Typ anzugeben, verwenden Sie das Suffix „LL“ oder „ll“. Das i64-Suffix wird weiterhin unterstützt, es wird jedoch nicht empfohlen. Es ist spezifisch für Microsoft und ist nicht portierbar. Beispiel:

unsigned val_1 = 328u;                  // Unsigned value
long val_2 = 0x7FFFFFL;                 // Long value specified
                                        //  as hex literal
unsigned long val_3 = 0776745ul;        // Unsigned long value
auto val_4 = 108LL;                           // signed long long
auto val_4 = 0x8000000000000000ULL << 16;     // unsigned long long

Zifferntrennzeichen: Sie können das einfache Anführungszeichen (Apostroph) verwenden, um Platzwerte in größeren Zahlen zu trennen, um den Menschen das Lesen zu erleichtern. Trennzeichen haben keine Auswirkungen auf die Kompilierung.

long long i = 24'847'458'121;

Gleitkommaliterale

Gleitkommaliterale geben Werte an, die Nachkommastellen aufweisen müssen. Diese Werte enthalten Dezimalstellen (.) und können Exponenten enthalten.

Gleitkommaliterale haben ein Significand (manchmal auch mantissa genannt), das den Wert der Zahl angibt. Sie haben einen Exponenten, der die Größe der Zahl angibt. Außerdem verfügen sie über ein optionales Suffix, das den Typ des Literals angibt. Das Significand wird als Sequenz von Ziffern gefolgt von einem Punkt angegeben, gefolgt von einer optionalen Abfolge von Ziffern, die den Bruchteil der Zahl darstellen. Beispiel:

18.46
38.

Sofern vorhanden, gibt der Exponent die Größe der Zahl als Zehnerpotenz an (siehe folgendes Beispiel):

18.46e0      // 18.46
18.46e1      // 184.6

Der Exponent kann mit e oder E, die dieselbe Bedeutung haben, angegeben werden, gefolgt von einem optionalen Zeichen (+ oder -) und einer Abfolge von Ziffern. Wenn ein Exponent vorhanden ist, ist das nachfolgende Dezimaltrennzeichen in ganzen Zahlen wie 18E0 nicht erforderlich.

Gleitkommaliterale werden standardmäßig eingegeben double. Bei Verwendung der Suffixe f oder l oder F ( L bei dem Suffix wird die Groß-/Kleinschreibung nicht beachtet), kann das Literal als float oder long doubleangegeben werden.

Obwohl long double und double dieselbe Darstellung aufweisen, sind sie nicht derselbe Typ. Sie können z. B. überladene Funktionen wie

void func( double );

and

void func( long double );

Boolesche Literale

Die booleschen Literale sind true und false.

Zeigerliteral (C++11)

C++ führt das nullptr Literal ein, um einen initialisierten Nullzeiger anzugeben. Im portablen Code nullptr sollten anstelle von Null- oder Makros vom typ integralen Typ verwendet werden, z NULL. B. .

Binäre Literale (C++14)

Ein binäres Literale kann durch die Verwendung des Präfix 0B oder 0b, gefolgt durch eine Sequenz von mehreren 1 und 0 angegeben werden.

auto x = 0B001101 ; // int
auto y = 0b000001 ; // int

Vermeiden der Verwendung von Literalen als „magische Konstanten“

Auch wenn Sie Literale direkt in Ausdrücken und Anweisungen verwenden können, ist es nicht immer ein guter Programmierstil:

if (num < 100)
    return "Success";

Im vorherigen Beispiel empfiehlt es sich, eine benannte Konstante zu verwenden, die eine klare Bedeutung vermittelt, z. B. "MAXIMUM_ERROR_THRESHOLD". Und wenn der Rückgabewert "Success" von Endbenutzern angezeigt wird, ist es möglicherweise besser, eine benannte Zeichenfolgenkonstante zu verwenden. Sie können Zeichenfolgenkonstanten an einem einzelnen Speicherort in einer Datei beibehalten, die in andere Sprachen lokalisiert werden kann. Die Verwendung von benannten Konstanten hilft Ihnen und anderen, die Absicht des Codes zu verstehen.

Siehe auch

Lexikalische Konventionen
C++-Zeichenfolgenliterale
Benutzerdefinierte C++-Literale