C++ Data Types

Il C contempla cinque tipi dati di base: void, int, float, double, and char.

Type	Description
void	nessuna rappresentazione associata
int	numeri interi
float	numeri in virgola mobile (floating-point) a singola precisione
double	numeri in virgola mobile a doppia precisione
char	caratteri

Oltre a questi il C++ ne definisce altri due: bool e wchar_t.

Type	Description
bool	Valore booleano quindi true (vero) o false (falso)
wchar_t	wide char, carattere esteso per rappresentazione di simboli di alfabeti non latini

Type Modifiers

Alcuni di questi tipi di dati possono essere modificati usando le parole riservate signed, unsigned, short e long. Quando uno di questi modificatori viene usato a se state il compilatore assume che ci si riferisca ad un int. Ecco una lista di possibili data-type (tipi equivalenti vengono mostrati sulla stessa riga):

numeri interi
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
numeri a virgola mobile (floating point types)
float
double
long double
tipi di interi talvolta supportati
long long	long long int	signed long long	signed long long int
unsigned long long		unsigned long long int

Tipo dati, dimensioni e range di valori

La dimensione e il range di valori di qualsiasi tipo di dati è dipendente dall'architettura della macchina e dal compilatore. Potete usare l'operatore /it/keywords/sizeof per determinare la dimensione di qualsiasi tipo di dati (spesso espresso come numero di byte). Molte architetture tuttavia implementano dati con un dimensione standard. Spesso variabili dichiarate come int o float sono a 32 bit, i char sono a 8 bit e double sono a 64 bit. Le variabili bool sono spesso realizzate a 8 bit e gli interi long long a 64 bit. L'header "cfloat" (o "float.h") definisce i range per i numeri in virgola mobile, mentre "climits" (o "limits.h") defisce il range per gli interi.

I limite dei valori numerici sono nell'header <limits>. I "templated values" di /it/limits/numeric_limits fornisce rappresentazioni numeriche dipendenti dal sistema dei tipi di dati usati nel C++. Usate la funzione approriata, tra quelle elencate, e un certo tipo dati come argomento del template. Notare che di numeric_limits si può fare l'overload per tipi di dati definiti dal programmatore.

Metodo o\\ constante	Return	Descrizione
is_specialized	bool
radix	int	base of exponent
digits	int	number of radix digits in mantissa
digits10	int	number of base 10 digits in mantissa
is_signed	bool
is_integer	bool
is_exact	bool
min()	<type>	smallest number that can be respresented (not the most negative)
max()	<type>	largest number
epsilon()	<type>	inherent representation error value
round_error()	<type>	maximum rounding adjustment possible
infinity()	<type>
quiet_NaN()	<type>	invalid number that does not signal floating point error
signaling_NaN()	<type>	invalid number that signals floating point error
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, ... }

L'uso più frequente è quello del controllo dei limiti per determinare il valore massimo o minimo che un tipo dati può contenere. Il codice seguente stampa i valori minini e massimi per un dato dichiarato come short.

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

Interpretazione delle dichiarazioni di data type

Interpretare una dichiarazione è solitamente intuitivo.

  int i

definisce una variabile intera con segno.

Tuttavia può essere compliato cercare di interpretare dichiarazione di data type più complicate:

  double **d[8]              // hmm...
  char *(*(**foo [][8])())[] // Cos'è 'foo'?

Potete costruire il significato delle dichiarazioni appena mostrate usando queste 3 regole:

1. Iniziate la dichiarazione con nome della variabile (d o foo negli esempi citati)
2. Finite la dichiarazione con il tipo di dato (double o char)
3. Completate la parte interna muovendovi a destra quando possibile, altrimenti a sinistra quando dovete. (Le parentesi potrebbero costringervi a procedere verso sinistra.)

Esempio:

Espressione	Significato
double %%**%%d[8];
double %%**%%d[8];	**d è ... double**
double %%**%%d[8];	d è **un array of 8** ... double
double **d[8];	d è un array di 8 **puntatori a** ... double
double %%**%%d[8];	d è un array di 8 puntatori verso **puntatori di** double

Altro esempio:

Expression	Meaning
char *(*(%%**%%foo [][8])())[]
char *(*(%%**%%foo [][8])())[]	**foo is ... char**
char *(*(%%**%%foo [][8])())[]	foo is **an array of** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of **an array of 8** ... char
char *(*(**foo [][8])())[]	foo is an array of an array of 8 **pointer to** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of an array of 8 pointer to **pointer to** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of an array of 8 pointer to pointer to **function returning** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of an array of 8 pointer to pointer to function returning **pointer to** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of an array of 8 pointer to pointer to function returning pointer to **array of** ... char
char *(*(%%**%%foo [][8])())[]	foo is an array of an array of 8 pointer to pointer to function returning pointer to array of **pointer to** char

Per una spiegazione più dettagliata andate alla descrizione di Steve Friedl's su come leggere dichiarazioni in C alla pagina http:www.unixwiz.net/techtips/reading-cdecl.html.