Librería estándar de C++<cstdint>

<cstdint><cstdint> es un archivo de cabecera introducido en C++11 que define un conjunto de tipos de enteros de ancho fijo. Estos tipos tienen el mismo tamaño y rango de representación en diferentes plataformas.

¿Por qué usar?<cstdint>

En C++, los tipos de enteros estándar (comoint、longetc.) tienen un tamaño y un rango de representación que dependen del compilador y de la plataforma. Esto puede provocar que los programas compilados en diferentes plataformas tengan un comportamiento inconsistente. El uso de<cstdint>los tipos de enteros de ancho fijo definidos en <cstdint> puede evitar estos problemas, ya que tienen el mismo tamaño y rango de representación en todas las plataformas.

Definición y sintaxis

<cstdint><cstdint> define los siguientes tipos de enteros:

  • int8_tint8_t: entero con signo de 8 bits
  • uint8_tuint8_t: entero sin signo de 8 bits
  • int16_tint16_t: entero con signo de 16 bits
  • uint16_tuint16_t: entero sin signo de 16 bits
  • int32_tint32_t: entero con signo de 32 bits
  • uint32_tuint32_t: entero sin signo de 32 bits
  • int64_tint64_t: entero con signo de 64 bits
  • uint64_tuint64_t: entero sin signo de 64 bits

Además, se definen los tipos de enteros de ancho máximo:

  • intmax_tintmax_t: entero con signo de ancho máximo
  • uintmax_tuintmax_t: entero sin signo de ancho máximo

Así como los tipos utilizados para operaciones de bits:

  • intptr_tintptr_t: entero con signo lo suficientemente grande para almacenar el valor de un puntero
  • uintptr_tuintptr_t: entero sin signo lo suficientemente grande para almacenar el valor de un puntero

Ejemplo

A continuación se muestra un ejemplo del uso de<cstdint><cstdint>, que muestra cómo declarar y utilizar estos tipos.

Ejemplo

#include <iostream>
#include <cstdint>

int main() {
    // Declarar tipos de enteros de ancho fijo
    int8_t a = -128; // Valor mínimo
    uint8_t b = 255; // Valor máximo
    int16_t c = -32768;
    uint16_t d = 65535;
    int32_t e = -2147483648;
    uint32_t f = 4294967295U; // Usar el sufijo U para constantes sin signo
    int64_t g = -9223372036854775807LL; // Usar el sufijo LL para constantes de tipo long long
    uint64_t h = 18446744073709551615ULL; // Usar el sufijo ULL para constantes de tipo unsigned long long

    // Resultado de la salida
    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;
}

Resultado de la salida:

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

Tipos de enteros de ancho fijo

Los tipos de enteros de ancho fijo garantizan que las variables tengan un ancho fijo, lo que resulta muy útil cuando se necesita un control preciso del tamaño y la disposición de los datos. Su nomenclatura adopta la formaintN_tyuintN_t, dondeNN representa el ancho de bits.

  • int8_t, int16_t, int32_t, int64_tintN_t: tipo de entero con signo de ancho fijo.
  • uint8_t, uint16_t, uint32_t, uint64_tuintN_t: tipo de entero sin signo de ancho fijo.

Ejemplo

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

Tipos de enteros de ancho mínimo

Los tipos de enteros de ancho mínimo garantizan que las variables tengan al menos el ancho de bits especificado, lo que resulta útil cuando se necesita una garantía de ancho mínimo pero no un control preciso del ancho. Su nomenclatura adopta la formaint_leastN_tyuint_leastN_t。

  • int_least8_t, int_least16_t, int_least32_t, int_least64_tint_leastN_t: tipo de entero con signo de ancho mínimo.
  • uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_tuint_leastN_t: tipo de entero sin signo de ancho mínimo.

Ejemplo

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

Tipos de enteros de ancho más rápido

Los tipos de enteros de ancho más rápido garantizan que las variables tengan al menos el ancho de bits especificado y sean lo más rápidas posible en un sistema determinado. Su nomenclatura adopta la formaint_fastN_tyuint_fastN_t。

  • int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_tint_fastN_t: tipo de entero con signo de ancho más rápido.
  • uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_tuint_fastN_t: tipo de entero sin signo de ancho más rápido.

Ejemplo

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

Tipos especiales

  • intmax_tintmax_t: el tipo de entero con signo más grande que puede representarse.
  • uintmax_tuintmax_t: el tipo de entero sin signo más grande que puede representarse.
  • intptr_tintptr_t: tipo de entero con signo lo suficientemente grande para almacenar punteros.
  • uintptr_tuintptr_t: tipo de entero sin signo lo suficientemente grande para almacenar punteros.

Ejemplo

#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 valores límite

<cstdint><cstdint> también define un conjunto de macros para representar los valores límite de estos tipos.

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

Ejemplo

#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><cstdint> proporciona un conjunto de tipos de enteros de ancho fijo que tienen el mismo tamaño y rango de representación en diferentes plataformas. El uso de estos tipos puede mejorar la portabilidad y la previsibilidad del código. Al escribir programas C++ multiplataforma, se recomienda usar<cstdint>los tipos definidos en <cstdint>.

Otras extensiones