Bibliothèque standard C++<cstdint>

<cstdint>Il s'agit d'un fichier d'en-tête introduit par C++11, qui définit un ensemble de types entiers à largeur fixe ayant la même taille et la même plage de représentation sur différentes plateformes.

Pourquoi utiliser<cstdint>

En C++, les types entiers standard (tels queint、longetc.) ont des tailles et des plages de représentation qui dépendent du compilateur et de la plateforme. Cela peut entraîner un comportement incohérent dans les programmes compilés sur différentes plateformes. En utilisant<cstdint>les types entiers à largeur fixe qui y sont définis peuvent éviter ces problèmes, car ils ont la même taille et la même plage de représentation sur toutes les plateformes.

Définition et syntaxe

<cstdint>Les types entiers suivants sont définis :

  • int8_t: entier signé de 8 bits
  • uint8_t: entier non signé de 8 bits
  • int16_t: entier signé de 16 bits
  • uint16_t: entier non signé de 16 bits
  • int32_t: entier signé de 32 bits
  • uint32_t: entier non signé de 32 bits
  • int64_t: entier signé de 64 bits
  • uint64_t: entier non signé de 64 bits

De plus, les types entiers de largeur maximale sont définis :

  • intmax_t: entier signé de largeur maximale
  • uintmax_t: entier non signé de largeur maximale

et les types utilisés pour les opérations bit à bit :

  • intptr_t: un entier signé suffisamment grand pour stocker la valeur d'un pointeur
  • uintptr_t: un entier non signé suffisamment grand pour stocker la valeur d'un pointeur

Exemple

Ci-dessous un exemple d'utilisation de<cstdint>Un exemple simple de ces types, montrant comment les déclarer et les utiliser.

Exemple

#include <iostream>
#include <cstdint>

int main() {
    // Déclarer des types d'entiers à largeur fixe
    int8_t a = -128; // Valeur minimale
    uint8_t b = 255; // Valeur maximale
    int16_t c = -32768;
    uint16_t d = 65535;
    int32_t e = -2147483648;
    uint32_t f = 4294967295U; // Utilisez le suffixe U pour désigner des constantes non signées
    int64_t g = -9223372036854775807LL; // Utilisez le suffixe LL pour désigner des constantes de type long long
    uint64_t h = 18446744073709551615ULL; // Utilisez le suffixe ULL pour désigner des constantes de type unsigned long long

    // Afficher les résultats
    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;
}

Résultat de sortie :

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

types entiers à largeur fixe

Les types entiers à largeur fixe garantissent que les variables ont une largeur fixe, ce qui est très utile lorsqu'un contrôle précis de la taille et de la disposition des données est nécessaire. Leur convention de nommage estintN_tetuintN_t, oùNIndique la largeur en bits.

  • int8_t, int16_t, int32_t, int64_t: type entier signé à largeur fixe.
  • uint8_t, uint16_t, uint32_t, uint64_t: type entier non signé à largeur fixe.

Exemple

#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;
}

Types entiers de largeur minimale

Les types entiers de largeur minimale garantissent que les variables ont au moins la largeur en bits spécifiée, ce qui est utile lorsqu'une garantie de largeur minimale en bits est requise mais qu'un contrôle précis de la largeur en bits n'est pas nécessaire. Leur convention de nommage estint_leastN_tetuint_leastN_t。

  • int_least8_t, int_least16_t, int_least32_t, int_least64_t: type entier signé de largeur minimale.
  • uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t: type entier non signé de largeur minimale.

Exemple

#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;
}

Types entiers de largeur la plus rapide

Les types entiers de largeur la plus rapide garantissent que les variables ont au moins la largeur en bits spécifiée et sont aussi rapides que possible sur un système donné. Leur convention de nommage estint_fastN_tetuint_fastN_t。

  • int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t: type entier signé de largeur la plus rapide.
  • uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t: type entier non signé de largeur la plus rapide.

Exemple

#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;
}

Types spéciaux

  • intmax_t: le plus grand type entier signé pouvant être représenté.
  • uintmax_t: le plus grand type entier non signé pouvant être représenté.
  • intptr_t: un type entier signé suffisamment grand pour stocker un pointeur.
  • uintptr_t: un type entier non signé suffisamment grand pour stocker un pointeur.

Exemple

#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;
}

Macros de valeurs limites

<cstdint>Un ensemble de macros est également défini pour représenter les valeurs limites de ces types.

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

Exemple

#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>Un ensemble de types entiers à largeur fixe est fourni, qui ont la même taille et la même plage de représentation sur différentes plateformes. L'utilisation de ces types peut améliorer la portabilité et la prévisibilité du code. Lors de l'écriture de programmes C++ multiplateformes, il est recommandé d'utiliser<cstdint>types définis dans.

autres extensions