Tipos de Datos de C++

Los programadores tienen acceso en C++ a cinco tipos de datos originados en C: void, int, float, double, and char.

Tipo	Descripción
void	no está asociado a ningún tipo
int	entero
float	número de punto flotante
double	número de punto flotante de doble precisión
char	caracter

Agregado a esto, C++ define dos tipos básicos más:

Tipo	Descripción
bool	Valor booleano, es decir "verdadero" o "falso"
wchar_t	caracter ancho

El próximo estándar C++0x agrega los siguientes tipos básicos:

Tipo	Descripción
char16_t	caracter en una codificación de 16 bits (UTF-16) (ver string)
char32_t	caracter en una codificación de 32 bits (UTF-32) (ver string)

Modificadores de tipo

Varios de estos tipos pueden ser modificados usando las palabras clave especiales: signed, unsigned, short y long. Si estas palabras especiales son usadas solas se asume que el tipo de datos es int. A continuación se presenta un listado de los tipos de datos posibles (con los equivalentes compartiendo una misma fila):

tipos de datos enteros
bool
char
signed char
unsigned char
wchar_t
short	short int	signed short	signed short int
unsigned short		unsigned short int
int	signed	signed int
unsigned		unsigned int
long	long int	signed long	signed long int
unsigned long		unsigned long int
tipos de datos flotantes
float
double
long double
tipos de datos enteros opcionales
long long	long long int	signed long long	signed long long int
unsigned long long		unsigned long long int

Tamaños y Rangos

El tamaño y rango de un tipo de datos depende del compilador. La palabra clave operador sizeof permite determinar el tamaño de un tipo de datos, expresado (usualmente) en la cantidad de bytes. Muchas arquitecturas implementan tipos de datos con tamaños estandarizados. Por ejemplo, los char son usualmente de 8-bits y los enteros int, así como los float, 32-bits. double es usualmente 64-bit. bool puede ser implementado como 8-bit. long long como 64-bit. El estándar de C++ asegura que sizeof(char) == 1.

Para obtener los rangos de los tipos de datos se puede acceder a las cabeceras <cfloat> (para flotantes) y <climits> (para enteros).

Los límites para los tipos de datos numéricos están definidos en la cabecera <limits>. Por medio del sistema de plantilla {{c|std::numeric_limits]] se provee representaciones numéricas de estos límites para los tipos de datos de C++. Para acceder a una de estas expresiones se invoca a la plantilla con el argumento deseado como se muestra en la tabla que sigue.

Invocación de los miembros de numeric_limits<type>::...
Método o Constante	Devuelve	Descripción
is_specialized	bool	Debe devolver true para todas las especializaciones del sistema de plantilla.
radix	int	Base del exponente dentro de la representación
digits	int	Nro. de dígitos en la base de la raíz, para la mantisa
digits10	int	Nro. de dígitos en base 10, para la mantisa
is_signed	bool	Devuelve true si type es un tipo con signo (es decir, acepta valores positivos y negativos)
is_integer	bool	Devuelve true si type es un tipo de datos entero
is_exact	bool	Devuelve true si la representación de datos numéricos es exacta
min()	<type>	El valor más pequeño representable (no el "más negativo")
max()	<type>	El valor más grande representable
epsilon()	<type>	Grado de error inherente a la representación
round_error()	<type>	Máximo ajuste posible al redondear
infinity()	<type>
quiet_NaN()	<type>	un número inválido que no marca a un error de punto flotante
signaling_NaN()	<type>	inválido que sí marca a un error de punto flotante
denorm_min()	<type>
min_exponent	int
min_exponent10	int
max_exponent	int
max_exponent10	int
has_infinity	bool
has_quiet_NaN	bool
has_signaling_NaN	bool
has_denorm	<type>_denorm_style
has_denorm_loss	bool
is_iec559	bool	conforms to IEC-559
is_bounded	bool
is_modulo	bool
traps	bool
tinyness_before	bool
round_style	float_round_style { round_to_nearest, ... }

El uso más común es la acotación de rangos, para determinar el mínimo y máximo valores posibles que un tipo de datos puede almacenar. Por ejemplo, el siguiente código imprime el valor mínimo y máximo que el tipo de datos short del compilador soporta:

  #include <limits>
  std::cout << "Maximum short value: " << std::numeric_limits<short>::max() << std::endl;
  std::cout << "Minimum short value: " << std::numeric_limits<short>::min() << std::endl;

Leer declaraciones de datos

Las declaraciones simples son fáciles de entender:

  int i

Para las expresiones complejas, se hace difícil entender su significado:

  double **d[8]              // hmm...
  char *(*(**foo [][8])())[] // ...¿qué rayos es ''foo''?

Para entender estas declaraciones, se puede seguir estas reglas:

1. Empiece con el nombre de la variable (d o foo)
2. Diríjase hacia el tipo de la variable (double o char)
3. Avance a la derecha cuando pueda, y a la izquierda cuando deba. (los paréntesis le pueden forzar a moverse a la izquierda)

Por ejemplo:

Expresión	Significado
double %%**%%d[8];
double %%**%%d[8];	**d es ... double**
double %%**%%d[8];	d es **un array de 8** ... double
double **d[8];	d es un array de 8 **punteros a** ... double
double %%**%%d[8];	d es un array de 8 punteros a **punteros a** double

Y otro ejemplo:

Expresión	Significado
char *(*(%%**%%foo [][8])())[]
char *(*(%%**%%foo [][8])())[]	**foo es ... char**
char *(*(%%**%%foo [][8])())[]	foo es **un array de** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de **un array de 8** ... char
char *(*(**foo [][8])())[]	foo es un array de un array de 8 **punteros a** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de un array de 8 punteros a **punteros a** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de un array de 8 punteros a punteros a **funciones devolviendo** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de un array de 8 punteros a punteros a funciones devolviendo **punteros a** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de un array de 8 punteros a punteros a funciones devolviendo punteros a **array de** ... char
char *(*(%%**%%foo [][8])())[]	foo es un array de un array de 8 punteros a punteros a funciones devolviendo punteros a array de **punteros a** char

Una explicación mucho más detallasa se puede encontrar en el tutorial para leer descripciones de C de Steve Friedl en [http:llwww.unixwiz.net/techtips/reading-cdecl.html].

• • TIP**: Usar typedef para crear sinónimos a declaraciones de tipos complejas ayuda a facilitar su comprensión.