C++-Standardbibliothek<cstdint>

<cstdint>Es ist eine mit C++11 eingeführte Header-Datei, die eine Reihe von Ganzzahltypen mit fester Breite definiert, die über verschiedene Plattformen hinweg dieselbe Größe und denselben Darstellungsbereich haben.

Warum verwenden<cstdint>

In C++ haben die Standard-Ganzzahltypen (wie z. B.int、longusw.) Größen und Darstellungsbereiche, die vom Compiler und der Plattform abhängen. Dies kann zu inkonsistentem Verhalten bei Programmen führen, die auf verschiedenen Plattformen kompiliert wurden. Die Verwendung von<cstdint>die darin definierten Integer-Typen mit fester Breite können diese Probleme vermeiden, weil sie auf allen Plattformen dieselbe Größe und denselben Darstellungsbereich haben.

Definition und Syntax

<cstdint>Die folgenden Integer-Typen sind definiert:

  • int8_t: 8-Bit-Ganzzahl mit Vorzeichen
  • uint8_t: 8-Bit-Ganzzahl ohne Vorzeichen
  • int16_t: 16-Bit-Ganzzahl mit Vorzeichen
  • uint16_t: 16-Bit-Ganzzahl ohne Vorzeichen
  • int32_t: 32-Bit-Ganzzahl mit Vorzeichen
  • uint32_t: 32-Bit-Ganzzahl ohne Vorzeichen
  • int64_t: 64-Bit-Ganzzahl mit Vorzeichen
  • uint64_t: 64-Bit-Ganzzahl ohne Vorzeichen

Darüber hinaus sind die Integer-Typen mit maximaler Breite definiert:

  • intmax_t: vorzeichenbehaftete Ganzzahl mit maximaler Breite
  • uintmax_t: vorzeichenlose Ganzzahl mit maximaler Breite

und die für Bitoperationen verwendeten Typen:

  • intptr_t: eine vorzeichenbehaftete Ganzzahl, die groß genug ist, um den Wert eines Zeigers zu speichern
  • uintptr_t: eine vorzeichenlose Ganzzahl, die groß genug ist, um den Wert eines Zeigers zu speichern

Beispiel

Nachfolgend ist ein Beispiel für die Verwendung von<cstdint>Ein einfaches Beispiel für diese Typen, das zeigt, wie man sie deklariert und verwendet.

Beispiel

#include <iostream>
#include <cstdint>

int main() {
    // Ganzzahltypen mit fester Breite deklarieren
    int8_t a = -128; // Minimalwert
    uint8_t b = 255; // Maximalwert
    int16_t c = -32768;
    uint16_t d = 65535;
    int32_t e = -2147483648;
    uint32_t f = 4294967295U; // Verwende das Suffix U, um unsigned-Konstanten zu kennzeichnen
    int64_t g = -9223372036854775807LL; // Verwende das Suffix LL, um long-long-Konstanten zu kennzeichnen
    uint64_t h = 18446744073709551615ULL; // Verwende das Suffix ULL, um unsigned long long-Konstanten zu kennzeichnen

    // Gib die Ergebnisse aus
    std::cout << "int8_t: " << static_cast<int>(a) << std::endl;
    std::cout << "uint8_t: " << static_cast<unsigned int>(b) << std::endl;
    std::cout << "int16_t: " << c << std::endl;
    std::cout << "uint16_t: " << d << std::endl;
    std::cout << "int32_t: " << e << std::endl;
    std::cout << "uint32_t: " << f << std::endl;
    std::cout << "int64_t: " << g << std::endl;
    std::cout << "uint64_t: " << h << std::endl;

    return 0;
}

Ausgabeergebnis:

int8_t: -128
uint8_t: 255
int16_t: -32768
uint16_t: 65535
int32_t: -2147483648
uint32_t: 4294967295
int64_t: -9223372036854775807
uint64_t: 18446744073709551615

Ganzzahltypen mit fester Breite

Ganzzahltypen mit fester Breite stellen sicher, dass Variablen eine feste Breite haben, was sehr nützlich ist, wenn eine präzise Kontrolle über Datengröße und Layout erforderlich ist. Ihre Namenskonvention istintN_tunduintN_t, wobeiNGibt die Bitbreite an.

  • int8_t, int16_t, int32_t, int64_t: vorzeichenbehafteter Ganzzahltyp mit fester Breite.
  • uint8_t, uint16_t, uint32_t, uint64_t: vorzeichenloser Ganzzahltyp mit fester Breite.

Beispiel

#include <cstdint>
#include <iostream>

int main() {
    int8_t a = -128;
    uint8_t b = 255;
    int32_t c = 2147483647;
    uint64_t d = 18446744073709551615U;

    std::cout << "a = " << static_cast<int>(a) << std::endl;
    std::cout << "b = " << static_cast<unsigned>(b) << std::endl;
    std::cout << "c = " << c << std::endl;
    std::cout << "d = " << d << std::endl;

    return 0;
}

Integer-Typen mit minimaler Breite

Integer-Typen mit minimaler Breite stellen sicher, dass Variablen mindestens die angegebene Bitbreite haben, was nützlich ist, wenn eine garantierte Mindestbitbreite erforderlich ist, aber keine präzise Kontrolle über die Bitbreite benötigt wird. Ihre Namenskonvention istint_leastN_tunduint_leastN_t。

  • int_least8_t, int_least16_t, int_least32_t, int_least64_t: vorzeichenbehafteter Integer-Typ mit minimaler Breite.
  • uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t: vorzeichenloser Integer-Typ mit minimaler Breite.

Beispiel

#include <cstdint>
#include <iostream>

int main() {
    int_least8_t a = -128;
    uint_least8_t b = 255;
    int_least32_t c = 2147483647;
    uint_least64_t d = 18446744073709551615U;

    std::cout << "a = " << static_cast<int>(a) << std::endl;
    std::cout << "b = " << static_cast<unsigned>(b) << std::endl;
    std::cout << "c = " << c << std::endl;
    std::cout << "d = " << d << std::endl;

    return 0;
}

Integer-Typen mit schnellster Breite

Integer-Typen mit schnellster Breite stellen sicher, dass Variablen mindestens die angegebene Bitbreite haben und auf einem gegebenen System so schnell wie möglich sind. Ihre Namenskonvention istint_fastN_tunduint_fastN_t。

  • int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t: vorzeichenbehafteter Integer-Typ mit schnellster Breite.
  • uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t: vorzeichenloser Integer-Typ mit schnellster Breite.

Beispiel

#include <cstdint>
#include <iostream>

int main() {
    int_fast8_t a = -128;
    uint_fast8_t b = 255;
    int_fast32_t c = 2147483647;
    uint_fast64_t d = 18446744073709551615U;

    std::cout << "a = " << static_cast<int>(a) << std::endl;
    std::cout << "b = " << static_cast<unsigned>(b) << std::endl;
    std::cout << "c = " << c << std::endl;
    std::cout << "d = " << d << std::endl;

    return 0;
}

Spezielle Typen

  • intmax_t: der größte vorzeichenbehaftete Ganzzahltyp, der dargestellt werden kann.
  • uintmax_t: der größte vorzeichenlose Ganzzahltyp, der dargestellt werden kann.
  • intptr_t: ein vorzeichenbehafteter Ganzzahltyp, der groß genug ist, um einen Zeiger zu speichern.
  • uintptr_t: ein vorzeichenloser Ganzzahltyp, der groß genug ist, um einen Zeiger zu speichern.

Beispiel

#include <cstdint>
#include <iostream>

int main() {
    intmax_t max_int = INTMAX_MAX;
    uintmax_t max_uint = UINTMAX_MAX;
    intptr_t ptr_int = reinterpret_cast<intptr_t>(&max_int);
    uintptr_t ptr_uint = reinterpret_cast<uintptr_t>(&max_uint);

    std::cout << "max_int = " << max_int << std::endl;
    std::cout << "max_uint = " << max_uint << std::endl;
    std::cout << "ptr_int = " << ptr_int << std::endl;
    std::cout << "ptr_uint = " << ptr_uint << std::endl;

    return 0;
}

Grenzwert-Makros

<cstdint>Es ist außerdem eine Reihe von Makros definiert, um die Grenzwerte dieser Typen darzustellen.

  • INT8_MIN, INT8_MAX, UINT8_MAX
  • INT16_MIN, INT16_MAX, UINT16_MAX
  • INT32_MIN, INT32_MAX, UINT32_MAX
  • INT64_MIN, INT64_MAX, UINT64_MAX

Beispiel

#include <cstdint>
#include <iostream>

int main() {
    std::cout << "INT8_MIN = " << static_cast<int>(INT8_MIN) << std::endl;
    std::cout << "INT8_MAX = " << static_cast<int>(INT8_MAX) << std::endl;
    std::cout << "UINT8_MAX = " << static_cast<unsigned>(UINT8_MAX) << std::endl;

    std::cout << "INT32_MIN = " << INT32_MIN << std::endl;
    std::cout << "INT32_MAX = " << INT32_MAX << std::endl;
    std::cout << "UINT32_MAX = " << UINT32_MAX << std::endl;

    return 0;
}

<cstdint>Es wird eine Reihe von Ganzzahltypen mit fester Breite bereitgestellt, die auf verschiedenen Plattformen dieselbe Größe und denselben Darstellungsbereich haben. Die Verwendung dieser Typen kann die Portabilität und Vorhersagbarkeit des Codes verbessern. Beim Schreiben plattformübergreifender C++-Programme wird empfohlen,<cstdint>Typen, die definiert sind in.

Weitere Erweiterungen