Holà,
Los tipos 'nativos' de C y de C++ son :
**** integer types ****
char : bastante para contenir un 'execution caracter set'
signed char, short, int, long son
signed integers types. No se sabe cuanto occupan cada uno de esos tipos (sus tamaños) pero la norma indica lo mìnimo que tiene que caber en cada uno de ellos :
signed char [-127;128[
short [-32767,32768[
int [-32767,32768[
long [-2147483647,2147483648[
C define tambien
long long que no existe todavia en C++ pero me parece que debe ser introducido con C++0x.
long long [-9223372036854775807,9223372036854775808[
C++ tiene
bool que puede contener
true/false. En C90 no hay boolean tipo pero en C99 hay
_Bool que debe poder contenir 0 y 1.
Estos tipos existen tambien en unsigned : unsigned char, unsigned short, unsigned int, unsigned long (y unsigned long long en C) con valores :
unsigned char [0;255[
unsigned short [0;65535[
unsigned int [0;65535[
unsigned long [0;4294967295[
unsigned long long [0;18446744073709551615[
Ai que notar que signed char != char != unsigned char : son tres tipos distinctos. Pero short/signed short, int/signed int, long/signed long, long long/signed long long son los mismos.
Tambien sizeof(char)==1 esto siempre aun que char puede occupar mas de 8 bits.
En los ordenadores modernos en 32 bits, los tipos suelen ser :
char/unsigned char : 8 bits
short/unsigned short : 16 bits
int/unsigned int : 32 bits
long/unsigned long : 32 bits
long long/unsigned long long : 64 bits.
En 64 bits, int, long pueden ser en 64 bits sin que sea eso la norma.
En desarrollo para lo embedido (? embedded), es todavia normal trabajar con int/unsigned int en 16 bits. Existe tambien procesador con char sobre 10 bits y short con 20 bits.
Lo que tienes que recordar :
char <= short <= int <= long <= long long
unsigned char <= unsigned short <= unsigned int <= unsigned long <= unsigned long long
y los intervales garantizados por la norma :
signed char [-127;128[
short [-32767,32768[
int [-32767,32768[
long [-2147483647,2147483648[unsigned char [0;255[
unsigned short [0;65535[
unsigned int [0;65535[
unsigned long [0;4294967295[
unsigned long long [0;18446744073709551615[Los mìnimos y los maximos de cada tipos te lo da el compilador :
En C, estan definidos en <limits.h>
#define CHAR_BIT specific compiler value
#define CHAR_MAX specific compiler value
#define CHAR_MIN specific compiler value
#define INT_MAX specific compiler value
#define INT_MIN specific compiler value
#define LONG_MAX specific compiler value
#define LONG_MIN specific compiler value
#define LLONG_MAX specific compiler value
#define LLONG_MIN specific compiler value
#define MB_LEN_MAX specific compiler value
#define SCHAR_MAX specific compiler value
#define SCHAR_MIN specific compiler value
#define SHRT_MAX specific compiler value
#define SHRT_MIN specific compiler value
#define UCHAR_MAX specific compiler value
#define USHRT_MAX specific compiler value
#define UINT_MAX specific compiler value
#define ULONG_MAX specific compiler value
#define ULLONG_MAX specific compiler value
En C++, estan definidos en <limits> y se obtene los min/max con dedicado std::numeric_limits :
std::numeric_limits<signed char>::min()
std::numeric_limits<signed char>::max()
std::numeric_limits<unsigned char>::min()
std::numeric_limits<unsigned char>::max()
std::numeric_limits<short>::min()
std::numeric_limits<short>::max()
std::numeric_limits<unsigned short>::min()
std::numeric_limits<unsigned short>::max()
std::numeric_limits<int>::min()
std::numeric_limits<int>::max()
std::numeric_limits<unsigned int>::min()
std::numeric_limits<unsigned int>::max()
std::numeric_limits<long>::min()
std::numeric_limits<long>::max()
std::numeric_limits<unsigned long>::min()
std::numeric_limits<unsigned long>::max()
Tambien podria hablar de int
N_t, uint
N_t y otros tipos definidos en <stdint.h> en C99, que no existen en C++03 pero son definidos en C++0X en <cstdint>. Esos tipos son definidos para garantizar su tamaño : exacto (
intN_t), a minimo (int_leastN_t) o optimizado ((int_fastN_t)
**** real types ****
C y C++ definen 3 tipos : float, double y long double con la restricción : lo que cabé en float, debe caber en double y lo que cabe en double debe caber en long double.
Y tambien tienes min/max par esos tipos en <float.h> en C y con std::numeric_limits<float/double/long double> en C++ con valores al minimo de 1.17549435E-38F y al maximo de 3.40282347E+38F par esos tres tipos.
Pero las valores suelen ser :#include <float.h>
FLT_MIN 1.17549435E-38F
FLT_MAX 3.40282347E+38F
DBL_MIN 2.2250738585072014E-308
DBL_MAX 1.7976931348623157E+308
LDBL_MIN 3.3621e-4932
LDBL_MAX - 1.18973e+4932
y en C++
#include <iostream>
#include <limits>
template<typename type>
void dump()
{
std::cout<<std::numeric_limits<type>::min()<<" ; "<<std::numeric_limits<type>::max()<<"n";
}
int main()
{
dump<float>();
dump<double>();
dump<long double>();
return 0;
}
produe con mi ordenador (puede cambiar selun tu compilador/OS/processor) :
1.17549e-038 ; 3.40282e+038
2.22507e-308 ; 1.79769e+308
3.3621e-4932 ; 1.18973e+4932
Aun que no es normativo, los tipos real suelen seguir la norma IEC 60559. Los tipos
real suelen ser representado con
[S|Exponent| fraction ]
S : one bit
Exponent y fraction van a ser diferentes segun que sea float, double o long double
float : 32 bits con 8 bit para exponent y 23 bit para fraccion
double : 64 bits con 11 bit para exponent y 52 bit para fraccion
long double : 96 bits con 15 bit para exponent y 80 bit para fraccion
El modo de calculo de los reales es un poco tecnico par ser explicado aqui. Te puedes referir a la entrada de wikipedia que me parece bastante clara :
IEEE 754-1985Los tamaños de float (32bits), double (64 bits) y long double (96 bits) no dependen tanto de saber si tienes processor/OS de 32 o 64 bits porque el calculo con tipos real tiene una unidad dedicada en el processor. De memoria, ya el intel 8087 tenia float sobre 32bits y double sobre 64 bits (long double sobre 80 bits me parece). Cuando al mismo tiempo, el 8086 estaba sobre 16 bits (int == short == 16 bits). Aunque es verda que 8086 y 8087 son de un dato que los menos de veinte años no se pueden recordar
Los problemas con los tipos
real es que necesitan rapidamente conocimiento matématico por problemas de representacion, convercion, precicion, error de calculo etc. Un documento muy interesante à leer :
What Every Computer Scientist Should Know About Floating-Point Arithmetic de David Goldberg
**** y ademas ****
todavia queda de decir sobre los tipos
pointers y
void (C++) que tambien hacen parte de tipos fundamuntales del lenguage.
