Einige Typen sind plattform- und andere compilerabhängig. Deshalb sind folgende Infos nicht als uneingeschränkt gültig zu betrachten! (Der GNU-Compiler kann z.B. einige Typen anders interpretieren als z.B. der MS VS-Compiler.)

Hier ist eine kleine Zusammenfassung aus den Seiten http://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Primitive-Types und http://www.gnu.org/software/libc/manual/html_node/Range-of-Type.html

(Der C99-Standard erweitert die Ranges um die 64-Bit Typen.)

Type Name	Bytes	Other Names	Range of Values	Kommentar
signed char	1	none	SCHAR_MIN to SCHAR_MAX (−128 to 127)
unsigned char	1	none	0 to 255
char	1	none	CHAR_MIN to CHAR_MAX. Depending on your system, the char data type is defined as having the same range as either the signed char or the unsigned char data type.
short int	2	short, signed short int, signed short	SHRT_MIN to SHRT_MAX (−32.768 to 32.767)
unsigned short int	2	unsigned short	0 to 65.535
int	4	signed int, signed	INT_MIN to INT_MAX (−2.147.483.648 to 2.147.483.647)
unsigned int	4	unsigned	0 to 4.294.967.295
long int	4, kann 8 Byte sein (auf 64-Bit Systemen)	long, signed long int, signed long	LONG_MIN to LONG_MAX (−2.147.483.648 to 2.147.483.647)
unsigned long int	4, kann 8 Byte sein (auf 64-Bit Systemen)	unsigned long	0 to 4.294.967.295
long long int	8	long long, signed long long int, signed long long	LLONG_MIN to LLONG_MAX (−9.223.372.036.854.775.808 to 9.223.372.036.854.775.807)	Kein Bestandteil von C89, jedoch von C99 und GNU C extension.
unsigned long long int	8	unsigned long long	0 to 18.446.744.073.709.551.615	Kein Bestandteil von C89, jedoch von C99 und GNU C extension.
float			FLT_MIN (darf nicht größer als 1e-37 sein) to FLT_MAX (darf nicht kleiner als 1e37 sein)
double			DBL_MIN to DBL_MAX
long double			LDBL_MIN to LDBL_MAX

Hier ist ein Auszug aus der Seite http://msdn.microsoft.com/en-us/library/s3f49ktz(v=vs.100).aspx

Für alle Fälle gilt: char ⇐ short ⇐ int ⇐ long ⇐ long long

Zur Kurzbeschreibung der 64-bit Datenmodelle

Mit diesem Beispiel finden wir die Limits für "int" heraus:

#include <iostream>
#include <limits>
 
using namespace std;
 
int main()
{
	cout << "int: min       = " << numeric_limits<int>::min()	<< endl;
	cout << "int: max       = " << numeric_limits<int>::max()	<< endl;
	cout << "int: digits    = " << numeric_limits<int>::digits	<< endl;
	cout << "int: is_signed = " << numeric_limits<int>::is_signed	<< endl;
 
	return 0;
}

Mit diesem Beispiel finden wir heraus, wie viele Bytes die Variablen je nach Typ im Speicher belegen:

//
// Das Programm gibt die Byte-Größen von unterschiedlichen Datentypen aus.
//
 
 
// ---------- Diese Defines bitte stets auf die passende Werte setzen! ----------
//
#define ARCH		"x86_64"
#define BS		"W2K8 SP2"
#define COMPILER	"MS VS2010"
//
// --------------------
 
 
 
#include <stdio.h>
 
 
 
// Bestimmung der Bit-Architektur (32-/64-Bit)
#if (defined SUNx86_32) || (defined SPARC_32) || (defined LINUX_x86) || (defined AIX_PPC_32) || (defined _WIN32 && !defined _WIN64)
	#define BIT_ARCH	32
#elif (defined SUNx86_64) || (defined SPARC_64) || (defined LINUX_x86_64) || (defined AIX_PPC_64) || (defined _WIN64)
	#define BIT_ARCH	64
#else
	#undef BIT_ARCH
#endif
 
#if !defined BIT_ARCH
	#error "BIT_ARCH is not defined"
#endif
 
#if BIT_ARCH == 32
	#define BITMODE		"32-Bit"
#elif BIT_ARCH == 64
	#define BITMODE		"64-Bit"
#else
	#define BITMODE		"undefined"
#endif
 
 
 
#define PRINT_SIZE_OF_TYPE(x)	{ int iSizeOfType = sizeof(x); printf("%2d\t(" #x ")\n", iSizeOfType); }
 
 
int main (int argc, char *argv[])
{
	printf("\nUEbersetzt auf folgendem System:\n\n");
	printf("Architektur:    %s\n", ARCH);
	printf("Betriebssystem: %s\n", BS);
	printf("32-/64-Bit:     %s\n", BITMODE);
	printf("Compiler:       %s\n", COMPILER);
 
	printf("\nsizeof\tType\n");
 
	PRINT_SIZE_OF_TYPE(void*);
 
	PRINT_SIZE_OF_TYPE(char);
	PRINT_SIZE_OF_TYPE(unsigned char);
	PRINT_SIZE_OF_TYPE(short int);
	PRINT_SIZE_OF_TYPE(int);
	PRINT_SIZE_OF_TYPE(long int);
	PRINT_SIZE_OF_TYPE(unsigned long);
	PRINT_SIZE_OF_TYPE(long long int);
	PRINT_SIZE_OF_TYPE(float);
	PRINT_SIZE_OF_TYPE(double);
	PRINT_SIZE_OF_TYPE(long double);
	PRINT_SIZE_OF_TYPE(wchar_t);
 
	return 0;
}

Wobei die Zeile PRINT_SIZE_OF_TYPE(void*); die Pointer-Breite representiert.

Ausgabe:

UEbersetzt auf folgendem System:

Architektur:    x86_64
Betriebssystem: W2K8 SP2
32-/64-Bit:     64-Bit
Compiler:       MS VS2010

sizeof  Type
 8      (void*)
 1      (char)
 1      (unsigned char)
 2      (short int)
 4      (int)
 4      (long int)
 4      (unsigned long)
 8      (long long int)
 4      (float)
 8      (double)
 8      (long double)
 2      (wchar_t)

Stand: 24.02.2015
— : Jürgen Kreick

EOF