Fundamental types

(Véase también type para una visión general del sistema de tipos y la lista de utilidades relacionadas con tipos que proporciona la biblioteca de C++)

Los siguientes tipos se denominan colectivamente fundamental types :

• (posiblemente calificado-cv) void

(posiblemente calificado-cv) std::nullptr_t

(desde C++11)

• tipos integrales
• tipos de punto flotante

Contenidos 1 void 2 std::nullptr_t 3 Tipos integrales 3.1 Tipos enteros estándar 3.1.1 Modificadores 3.1.2 Propiedades 3.2 Tipos enteros extendidos 3.3 Tipo booleano 3.4 Tipos de caracteres 4 Tipos de punto flotante 4.1 Tipos de punto flotante estándar 4.2 Tipos de punto flotante extendidos 4.3 Propiedades 5 Rango de valores 6 Modelos de datos 7 Notas 8 Palabras clave 9 Informes de defectos 10 Referencias 11 Véase también

void

void — tipo con un conjunto vacío de valores. Es un tipo incompleto que no puede ser completado (en consecuencia, los objetos de tipo void no están permitidos). No existen arrays de void , ni referencias a void . Sin embargo, punteros a void y funciones que retornan tipo void ( procedimientos en otros lenguajes) están permitidos.

std::nullptr_t Definido en el encabezado <cstddef> typedef decltype ( nullptr ) nullptr_t ; (desde C++11) std::nullptr_t es el tipo del literal de puntero nulo, nullptr . Es un tipo distinto que no es en sí mismo un tipo puntero o un tipo puntero a miembro. Todos sus prvalues son constantes de puntero nulo . sizeof ( std:: nullptr_t ) es igual a sizeof ( void * ) .

(desde C++11)

Tipos integrales

Tipos enteros estándar

int — tipo entero básico. La palabra clave int puede omitirse si se utiliza cualquiera de los modificadores listados abajo. Si no hay modificadores de longitud presentes, se garantiza que tendrá un ancho de al menos 16 bits. Sin embargo, en sistemas de 32/64 bits está casi exclusivamente garantizado que tendrá un ancho de al menos 32 bits (ver abajo).

Modificadores

Modifica el tipo entero básico. Puede mezclarse en cualquier orden. Solo puede haber uno de cada grupo en el nombre del tipo.

• Firmado:

signed — el tipo destino tendrá representación con signo (esta es la opción por defecto si se omite)

unsigned — el tipo destino tendrá representación sin signo

• Tamaño:

short — el tipo destino será optimizado para espacio y tendrá un ancho de al menos 16 bits.

long — el tipo destino tendrá un ancho de al menos 32 bits.

long long — el tipo destino tendrá un ancho de al menos 64 bits.

(desde C++11)

Nota: como con todos los especificadores de tipo, cualquier orden está permitido: unsigned long long int y long int unsigned long nombran el mismo tipo.

Propiedades

La siguiente tabla resume todos los tipos enteros estándar disponibles y sus propiedades en varios modelos de datos comunes:

Especificador de tipo	Tipo equivalente	Ancho en bits por modelo de datos
		Estándar de C++	LP32	ILP32	LLP64	LP64
signed char	signed char	al menos 8	8	8	8	8
unsigned char	unsigned char
short	short int	al menos 16	16	16	16	16
short int
signed short
signed short int
unsigned short	unsigned short int
unsigned short int
int	int	al menos 16	16	32	32	32
signed
signed int
unsigned	unsigned int
unsigned int
long	long int	al menos 32	32	32	32	64
long int
signed long
signed long int
unsigned long	unsigned long int
unsigned long int
long long	long long int (C++11)	al menos 64	64	64	64	64
long long int
signed long long
signed long long int
unsigned long long	unsigned long long int (C++11)
unsigned long long int

Nota: la aritmética de enteros se define de manera diferente para los tipos de enteros con signo y sin signo. Consulte operadores aritméticos , en particular desbordamientos de enteros .

std::size_t es el tipo entero sin signo del resultado del operador sizeof así como del operador sizeof... y del operador alignof (desde C++11) .

Tipos de enteros extendidos Los tipos de enteros extendidos están definidos por la implementación. Nótese que los tipos de enteros de ancho fijo son típicamente alias de los tipos de enteros estándar.

(desde C++11)

Tipo booleano

bool — tipo entero, capaz de contener uno de los dos valores: true o false . El valor de sizeof ( bool ) está definido por la implementación y puede diferir de 1 .

Tipos de caracteres

Los tipos de caracteres son tipos enteros utilizados para la representación de caracteres.

signed char — tipo para representación de caracteres con signo.

unsigned char — tipo para representación de caracteres sin signo. También se utiliza para inspeccionar representaciones de objetos (memoria en bruto).

char — tipo para representación de caracteres que puede procesarse más eficientemente en el sistema objetivo (tiene la misma representación y alineación que signed char o unsigned char , pero siempre es un tipo distinto). Las cadenas de caracteres multibyte utilizan este tipo para representar unidades de código. Para cada valor de tipo unsigned char en el rango [ ​ 0 ​ , 255 ] , convertir el valor a char y luego de vuelta a unsigned char produce el valor original. (desde C++11) El signo de char depende del compilador y la plataforma objetivo: los valores predeterminados para ARM y PowerPC son típicamente sin signo, los valores predeterminados para x86 y x64 son típicamente con signo.

wchar_t — tipo para representación de caracteres anchos (ver cadenas anchas ). Tiene el mismo tamaño, signo y alineación que uno de los tipos enteros, pero es un tipo distinto. En la práctica, es de 32 bits y contiene UTF-32 en Linux y muchos otros sistemas no Windows, pero de 16 bits y contiene unidades de código UTF-16 en Windows. El estándar solía requerir que wchar_t fuera lo suficientemente grande para representar cualquier punto de código de carácter admitido. Sin embargo, este requisito no se puede cumplir en Windows, por lo que se considera un defecto y se ha eliminado.

char16_t — tipo para representación de caracteres UTF-16, requerido para ser lo suficientemente grande para representar cualquier unidad de código UTF-16 (16 bits). Tiene el mismo tamaño, signo y alineación que std::uint_least16_t , pero es un tipo distinto. char32_t — tipo para representación de caracteres UTF-32, requerido para ser lo suficientemente grande para representar cualquier unidad de código UTF-32 (32 bits). Tiene el mismo tamaño, signo y alineación que std::uint_least32_t , pero es un tipo distinto.

(desde C++11)

char8_t — tipo para representación de caracteres UTF-8, requerido para ser lo suficientemente grande para representar cualquier unidad de código UTF-8 (8 bits). Tiene el mismo tamaño, signo y alineación que unsigned char (y por lo tanto, el mismo tamaño y alineación que char y signed char ), pero es un tipo distinto.

(desde C++20)

Además de los conteos mínimos de bits, el Estándar C++ garantiza que

1 == sizeof ( char ) ≤ sizeof ( short ) ≤ sizeof ( int ) ≤ sizeof ( long ) ≤ sizeof ( long long ) .

Nota: esto permite el caso extremo en el que los bytes tienen un tamaño de 64 bits, todos los tipos (incluyendo char ) tienen un ancho de 64 bits, y sizeof devuelve 1 para cada tipo.

Tipos de punto flotante

Tipos de punto flotante estándar

Los siguientes tres tipos y sus versiones calificadas cv se denominan colectivamente tipos estándar de punto flotante.

float — tipo de punto flotante de precisión simple. Normalmente formato IEEE-754 binary32 .

double — tipo de punto flotante de doble precisión. Normalmente formato IEEE-754 binary64 .

long double — tipo de punto flotante de precisión extendida. No necesariamente se corresponde con tipos requeridos por IEEE-754.

• formato IEEE-754 binary128 es utilizado por algunas implementaciones de HP-UX, SPARC, MIPS, ARM64 y z/OS.
• El más conocido formato IEEE-754 binary64-extendido es el formato de precisión extendida x87 de 80 bits . Es utilizado por muchas implementaciones x86 y x86-64 (una excepción notable es MSVC, que implementa long double en el mismo formato que double , es decir, binary64).
• En PowerPC se puede utilizar double-double .

Tipos de punto flotante extendidos Los tipos de punto flotante extendidos están definidos por la implementación. Pueden incluir tipos de punto flotante de ancho fijo .

(since C++23)

Propiedades

Los tipos de punto flotante pueden admitir valores especiales :

• infinito (positivo y negativo), ver INFINITY
• el cero negativo , - 0.0 . Se compara igual al cero positivo, pero es significativo en algunas operaciones aritméticas, p.ej. 1.0 / 0.0 == INFINITY , pero 1.0 / - 0.0 == - INFINITY ), y para algunas funciones matemáticas, p.ej. sqrt (std::complex)
• no-es-un-número (NaN), que no se compara igual con nada (incluyéndose a sí mismo). Múltiples patrones de bits representan NaNs, ver std::nan , NAN . Nótese que C++ no toma medidas especiales con los NaNs señalizados aparte de detectar su soporte mediante std::numeric_limits::has_signaling_NaN , y trata todos los NaNs como silenciosos.

Los números de punto flotante pueden utilizarse con operadores aritméticos + , - , / , y * así como diversas funciones matemáticas de <cmath> . Tanto los operadores incorporados como las funciones de biblioteca pueden generar excepciones de punto flotante y establecer errno como se describe en math errhandling .

Las expresiones de punto flotante pueden tener mayor rango y precisión que el indicado por sus tipos, consulte FLT_EVAL_METHOD . Las expresiones de punto flotante también pueden ser contraídas , es decir, calculadas como si todos los valores intermedios tuvieran rango y precisión infinitos, consulte #pragma STDC FP_CONTRACT . El C++ estándar no restringe la precisión de las operaciones de punto flotante.

Algunas operaciones con números de punto flotante se ven afectadas por y modifican el estado de the floating-point environment (especialmente, la dirección de redondeo).

Conversiones implícitas se definen entre tipos de punto flotante y tipos enteros.

Consulte límites de tipos de punto flotante y std::numeric_limits para detalles adicionales, límites y propiedades de los tipos de punto flotante.

Rango de valores

La siguiente tabla proporciona una referencia para los límites de las representaciones numéricas comunes.

Antes de C++20, el Estándar de C++ permitía cualquier representación de enteros con signo, y el rango mínimo garantizado para enteros con signo de N bits era desde \(\scriptsize -(2^{N-1}-1)\) -(2 N-1
-1) hasta \(\scriptsize +2^{N-1}-1\) +2 N-1
-1 (por ejemplo, −127 a 127 para un tipo con signo de 8 bits), lo que corresponde a los límites del complemento a uno o de la representación signo-magnitud .

Sin embargo, todos los compiladores de C++ utilizan complemento a dos como representación, y desde C++20, es la única representación permitida por el estándar, con el rango garantizado desde \(\scriptsize -2^{N-1}\) -2 N-1
hasta \(\scriptsize +2^{N-1}-1\) +2 N-1
-1 (por ejemplo, −128 hasta 127 para un tipo con signo de 8 bits).

Las representaciones de complemento a uno de 8 bits y signo-magnitud para char han sido deshabilitadas desde C++11 (mediante la resolución de CWG issue 1759 ), porque una unidad de código UTF-8 de valor 0x80 utilizada en un literal de cadena UTF-8 debe ser almacenable en un objeto de tipo char .

El rango para un tipo de punto flotante T se define de la siguiente manera:

• El rango mínimo garantizado es desde el número finito negativo más pequeño representable en T hasta el número finito positivo más grande representable en T .
• Si el infinito negativo es representable en T , el rango de T se extiende a todos los números reales negativos.
• Si el infinito positivo es representable en T , el rango de T se extiende a todos los números reales positivos.

Dado que el infinito negativo y positivo son representables en los formatos ISO/IEC/IEEE 60559 , todos los números reales se encuentran dentro del rango de valores representables de un tipo de punto flotante que cumple con ISO/IEC/IEEE 60559.

Tipo	Tamaño en bits	Formato	Rango de valores
			Aproximado	Exacto
carácter	8	con signo		−128 a 127
		sin signo		0 a 255
	16	UTF-16		0 a 65535
	32	UTF-32		0 a 1114111 ( 0x10ffff )
entero	16	con signo	± 3.27 · 10 4	−32768 a 32767
		sin signo	0 a 6.55 · 10 4	0 a 65535
	32	con signo	± 2.14 · 10 9	−2,147,483,648 a 2,147,483,647
		sin signo	0 a 4.29 · 10 9	0 a 4,294,967,295
	64	con signo	± 9.22 · 10 18	−9,223,372,036,854,775,808 a 9,223,372,036,854,775,807
		sin signo	0 a 1.84 · 10 19	0 a 18,446,744,073,709,551,615
punto flotante binario	32	IEEE-754	mínimo subnormal: ± 1.401,298,4 · 10 −45 mínimo normal: ± 1.175,494,3 · 10 −38 máximo: ± 3.402,823,4 · 10 38	mínimo subnormal: ±0x1p−149 mínimo normal: ±0x1p−126 máximo: ±0x1.fffffep+127
	64	IEEE-754	mínimo subnormal: ± 4.940,656,458,412 · 10 −324 mínimo normal: ± 2.225,073,858,507,201,4 · 10 −308 máximo: ± 1.797,693,134,862,315,7 · 10 308	mínimo subnormal: ±0x1p−1074 mínimo normal: ±0x1p−1022 máximo: ±0x1.fffffffffffffp+1023
	80 [nota 1]	x86	mínimo subnormal: ± 3.645,199,531,882,474,602,528 · 10 −4951 mínimo normal: ± 3.362,103,143,112,093,506,263 · 10 −4932 máximo: ± 1.189,731,495,357,231,765,021 · 10 4932	mínimo subnormal: ±0x1p−16445 mínimo normal: ±0x1p−16382 máximo: ±0x1.fffffffffffffffep+16383
	128	IEEE-754	mínimo subnormal: ± 6.475,175,119,438,025,110,924, 438,958,227,646,552,5 · 10 −4966 mínimo normal: ± 3.362,103,143,112,093,506,262, 677,817,321,752,602,6 · 10 −4932 máximo: ± 1.189,731,495,357,231,765,085, 759,326,628,007,016,2 · 10 4932	mínimo subnormal: ±0x1p−16494 mínimo normal: ±0x1p−16382 máximo: ±0x1.ffffffffffffffffffffffffffff p+16383

1. ↑ La representación del objeto generalmente ocupa 96/128 bits en plataformas de 32/64 bits respectivamente.

Nota: los límites reales (en oposición a los mínimos garantizados) sobre los valores representables por estos tipos están disponibles en C numeric limits interface y std::numeric_limits .

Modelos de datos

Las elecciones realizadas por cada implementación sobre los tamaños de los tipos fundamentales se conocen colectivamente como modelo de datos . Cuatro modelos de datos obtuvieron amplia aceptación:

Sistemas de 32 bits:

• LP32 o 2/4/4 ( int es de 16 bits, long y los punteros son de 32 bits)

• API Win16

• ILP32 o 4/4/4 ( int , long , y los punteros son de 32 bits);

• API Win32
• Sistemas Unix y similares a Unix (Linux, macOS)

Sistemas de 64 bits:

• LLP64 o 4/4/8 ( int y long son de 32 bits, los punteros son de 64 bits)

• API de Win32 (también llamada API de Windows) con objetivo de compilación ARM de 64 bits (AArch64) o x86-64 (también conocido como x64)

• LP64 o 4/8/8 ( int es de 32 bits, long y los punteros son de 64 bits)

• Sistemas Unix y similares a Unix (Linux, macOS)

Otros modelos son muy raros. Por ejemplo, ILP64 ( 8/8/8 : int , long , y los punteros son de 64 bits) solo apareció en algunos sistemas Unix tempranos de 64 bits (por ejemplo, UNICOS en Cray ).

Notas

Macro de prueba de características	Valor	Std	Característica
__cpp_unicode_characters	200704L	(C++11)	Nuevos tipos de caracteres ( char16_t y char32_t )
__cpp_char8_t	201811L	(C++20)	char8_t
	202207L	(C++23)	char8_t corrección de compatibilidad y portabilidad ( permitir inicialización de arrays (unsigned) char desde literales de cadena UTF-8 )

Palabras clave

void , bool , true , false , char , char8_t , char16_t , char32_t , wchar_t , int , short , long , signed , unsigned , float , double

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a estándares de C++ publicados anteriormente.

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
CWG 238	C++98	las restricciones impuestas a una implementación de punto flotante no estaban especificadas	especificado como sin restricción
CWG 1759	C++11	char no estaba garantizado que pudiera representar la unidad de código UTF-8 0x80	garantizado
CWG 2689	C++11	std::nullptr_t calificado con cv no era un tipo fundamental	lo es
CWG 2723	C++98	los rangos de valores representables para tipos de punto flotante no estaban especificados	especificado
P2460R2	C++98	wchar_t estaba obligado a poder representar códigos distintos para todos los miembros del conjunto de caracteres extendido más grande especificado entre las configuraciones regionales admitidas	no requerido

Referencias

Véase también

• Resumen del sistema de tipos de C++
• Especificadores y calificadores const-volatilidad (cv)
• Especificadores de duración de almacenamiento

Documentación de C para tipos aritméticos