Programmazione C Massimo Callisto De Donato

Transcript

1 Università degli studi di Camerino Scuola di scienze e tecnologia - Sezione Informatica Programmazione C Massimo Callisto De Donato massimo.callisto@unicam.it LEZIONE 3 TIPI DI DATO A.A. 2011/12

2 Tipi di dati

3 Tipi di dato In C esistono due categorie di tipi: primitivi e derivati. I tipi primitivi (o fondamentali): void enum char int float double I tipi derivati (o composti): array strutture unioni I secondi sono costruiti a partire dai primi e vengono usati per raggruppare variabili logicamente correlate. Il tipo void è un tipo di dato utilizzato rappresenta il valore vuoto. E.s.: si usa in funzioni che non restituiscono valori, nelle malloc.

4 Sintassi delle dichiarazioni Qualunque identificatore (variabile, funzione, ) deve essere dichiarato prima dell utilizzo. Dichiarare una variabile significa specificare a quale tipo appartiene al fine di dire al compilatore: Quanta memoria deve essere riservata Quali sono le operazioni ammesse su di essa. Sintassi di una dichiarazione: tipo variabile; //oppure elenco variabili separate da virgole; Esempi: char letter; int number, sum; float f, media; Non ci sono valori di default. Dobbiamo fare inizializzazioni esplicite: char letter = 'A'; int number = 0, sum = 2; float f = 2.178;

5 Tipi primitivi: i tipi int, float e double Il tipo int rappresenta interi tipicamente a 32 bit (4 byte). Il valore massimo è quindi 2^ Il tipo float rappresenta numeri reali in virgola mobile con precisione singola a 4 byte. Il tipo double rappresenta numeri reali in virgola mobile con precisione doppia a 8 byte. Le dimensioni effettive dipendono dall architettura della macchina che stiamo usando. Anche se possono cambiare assumiamo che: char <= int float <= double

6 Tipi primitivi: i tipi int, float e double short e long (quantificatori di dimensione) Modificano la memoria di default associata ad un tipo di variabile: short int è un int con dimensione minore o uguale a quella di int long int è un int maggiore o al più uguale a quella di int Dipende sempre dall architettura del sistema ma assumiamo che: short int <= int <= long int double <= long double

7 Tipi primitivi: i tipi int, float e double signed (int o char) e unsigned (int o char) Si applicano ai tipi char e int e fanno esplicitamente riferimento all aritmetica senza segno: I valori numerici possono essere solo positivi il range di int è +/ , il range di unsigned int è signed definisce che una variabile ha il segno anche se è ridondante. Spesso si usano delle abbreviazioni: short short int unsigned unsigned int Unsigned short unsigned short int unsigned long unsigned long int

8 Tipi primitivi: dimensioni Tipo Range Dimensione in memoria char 127 a +127oppure 0 a signed char 127 a unsigned char 0 a signed short int a unsigned short int 0 a signed int a o 4 unsigned int 0 a o 4 signed long int a o 8 unsigned long int 0 a o 8 signed long long int a unsigned long long int 0 a float a double a long double a , 12, o 16

9 Tipi di dato: char I char identificano caratteri alfanumerici, simboli di punteggiatura, spazi, etc. Li indichiamo tra apici (e.s. 'A', '0', '# ). Vedremo che 'A' (char) è diverso da "A" (vettore formato da 'A' e ' \0 ) I caratteri sono codificati (memorizzati) secondo lo standard ASCII: 8 bits (1 byte) per codificare un carattere 127 combinazioni. 255 Nella versione ASCII estesa. Ad ogni carattere associamo un codice univoco: Il carattere 'A' viene codificato mediante la sequenza binaria Corrisponde all intero positivo 65 I char possono essere manipolati come int dato che contengono interi. Supportano le tipiche operazioni su interi: addizione, sottrazione, uguaglianze,

10 Tipi di dato: char

11 Tipi di dato: char #include <stdio.h> #include <stdlib.h> int main() { char c; printf("inserisci un carattere: "); c = getchar(); printf("hai inserito una '%c' che ha valore %d\n", c, c); } return 0;

12 Tipi di dato: char /* Differenza di input */ #include <stdio.h> #include <stdlib.h> int main() { char c1; int c2; printf("inserisci un carattere: "); c1 = getchar(); printf("stesso catrattere da scanf: "); scanf("%d", &c2); printf("primo input '%d'\nsecondo input '%d'\n", c1, c2); } return 0;

13 Costanti Le costanti si riferiscono a valori fissi e noti a priori Quattro categorie: costanti carattere: 'A', '0', '#' le costanti intere: base decimali: 0, 89 base ottale (in base 8) precedute da 0: 012, (base 8) = (1 * 8^1) + (2 * 8^0) = = 10 77(base 8) = (7 * 8^1) + (7 * 8^0) = = 63 base esadecimale (in base 16) precedute da 0x oppure 0X: 0xAA, 0X77 costanti floating point: 23.56, costanti stringa: "stringa", "pippo"

14 Costanti Il compilatore sceglie automaticamente il tipo in base al valore Possiamo alterare il comportamento con i suffissi: Es.: Se int di default è int oppure long con L Sempre int ma unsigned se U Se è un float allora è un double. Possiamo usar F per un float oppure L per un long double // int 35000L -34L 10000U 19U // long int // unsigned int // double F // float L // long double

15 Costanti Esempi: #define BASE 10 #define BASE_8 012 #define BASE_16 0xA #define BASE_L 10L #define AREA #define STR pippo // intero // base ottale // base esadecimale // intero long // double // vettore di caratteri

16 Enum Si usano quando si vuole specificare un insieme preciso di valori che una variabile può assumere. Es: enum color {red, blue, green, yellow}; enum intensity {bright, medium, dark}; Sintassi generica: enum nome_tipo {lista_costanti}; Ai nomi delle costanti viene associato un valore intero di default basato sulla posizione nella lista: la prima costante assume valore 0 alla seconda uno, etc Il valore può essere modificato esplicitamente (es.: enum succ {success = 1, failure = 0})

17 Enum #include <stdio.h> int main() { enum days {Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}; enum days TheDay; int j = 0; printf("please enter the day of the week (0 to 6)\n"); scanf("%d",&j); TheDay = j; if(theday == Sunday TheDay == Saturday){ printf("weekend\n"); }else{ printf("work\n"); } } system("pause"); return 0;

18 Modificatori di accesso E possibile istruire il compilatore su come utilizzare una variabile. Sono i modificatori di accesso, ovvero parole chiavi da inserire prima del nome al momento della dichiarazione. const: il contenuto della variabile, assegnato in fase dichiarazione/inizializzazione, non può essere mai modificato static: una variabile viene dichiarata ed inizializzata una sola volta. A chiamate successive ci ricordiamo dell ultimo valore assunto. Variabili static globali diventano private a quel file. volatile: indica al compilatore che la variabile potrebbe essere modificata in modo inatteso dall esterno. Evita le ottimizzazioni del compilatore. register: richiede che la variabile sia mantenuta sempre in registro della CPU, o nella cache per richiamarla più velocemente. extern: quando uniamo più file oggetto, le variabili extern fanno riferimento a variabili globali dichiarate in un altro file oggetto. I collegamenti sono risolti dal linker

19 Modificatori di accesso // main.c #include <stdio.h> #include "bridge.h" // bridge.h int num(); #define PIPPO 120U /* extern */ int ggl; int main() { printf("%d, %d\n", PIPPO, ggl); num(); printf("%d, %d\n", PIPPO, ggl); return 0; } // file.c #include <stdio.h> /* static */ int ggl = 0; int num(){ printf("ciao mondo"); ggl++; return 0; }

20 Operatori

21 Operatori Tre tipi di operatori: assegnamento, aritmetici, relazionali. Operatore di assegnamento: variabile = espressione La valutazione (parte destra) viene assegnato alla variabile (parte sinistra): variabile espressione L assegnamento può comparire all interno di altre espressioni: y = 2 + (x = 7 * 3); Assegnamenti multipli tra tipi di variabili dello stesso tipo: int x = y = 5 Non vale: int z, f= 10.5, k = c ;

22 Operatori aritmeici Se / viene applicato ad interi, il resto viene troncato: 5 / 2 = 2 mentre 5.0/2 = 2.5 a % b restituisce il resto della divisione tra a e b e vale solo su operandi interi. Es: 6.98 % 3 // errore di compilazione! Possiamo scrivere: int a, b; a = b = 3; printf( %d, ++a%b); // stampa?

23 Operatori aritmetici L ordine di valutazione stabilisce quali operatori devono essere valutati per primi. Esempi: * 13 ~ 15 + (4 * 13) 16 / ~ (16 / 4) + 3 a * --b ~ (a++) - (5 * (--b)) [Se a = 5 e b = 6, il risultato è?] A parità di precedenza, l'associazione è tipicamente a sinistra (si scorre da sinistra a destra) ~ (15-4) - 13 = (4-13) = 15 - (-9) = = 24 // errore! Le priorità e l'associatività possono essere modificati con l uso di parentesi ()

24 Operatori aritmetici unari L incremento /decremento ++/-- aggiunge/sottrae una unità all operando ++x; ~ x = x + 1; --x; ~ x = x - 1; Possono precedere oppure seguire la variabile (con effetti diversi!): ++x (notazione prefissa) x++ (notazione postfissa); La differenza è nel valore restituito: notazione prefissa: prima si effettua l incremento/decremento, poi si valutata l espressione notazione postfissa: prima si valutata l espressione, poi si effettua l incremento/decremento Ad esempio, per n= 5 x = ++n; // x == 6 x = n++; // x == 5 a * --b ~ (a++) - (5 * (--b)) [Se a = 5 e b = 6, il risultato è?]

25 Operatori aritmetici abbreviazioni Esistono le forse compatte += e -= x += 9; ~ x = x + 9; Sintassi generica: operatore= dove operatore appartiene a {+, -, *, /, %} Esempi: a += 5 a = a + 5 a -= b a = a b a *= b + 4 a = a * (b + 4) Hanno la stessa priorità dell assegnamento semplice: a = 4; a -= 3 * ~ 4 - ((3 * 2) + 11) = 4-17 = -13

26 Operatori relazionali e logici Gli operatori relazionali stabiliscono relazioni di grandezza. Gli operatori logici stabiliscono relazioni di uguaglianza.

27 Operatori relazionali e logici In C non esiste un tipo booleano (true o false). Gli operatori relazionali (logici) restituiscono valori numerici: 0 per falso 1 per la verità Il risultato di un espressione può essere assegnato a variabili intere. x = 5 > 7; x = (9 <= 10) && 1 Possiamo usare (e come) enum?

28 Priorità degli operatori logici e relazionali: Gli operatori relazionali e && e!! hanno una precedenza inferiore rispetto a quelli aritmetici. && e hanno una precedenza inferiore rispetto a quelli relazionali. 10 > > (1 + 12) ritorna? (10 > 1) + 12 ~ vero + 12 = = > 1 == 12 ~ (10 > 1) == 12 restituisce 0 (falso) 1 0 && 0 ~ 1 (0 && 0) 1 (vero) L associazione è a sinistra: 13 > 7 >= 6 ~ (13 > 7) >= 6 1 >= 6 0 (falso) 13 > (7 >= 6) 13 > 1 1 (vero)

29 Operatore ternario L operatore ternario? rappresenta una valutazione/assegnazione La sintassi: expr1? expr2 : expr3 Restituisce expr2 se expr1 è vera; Restituisce expr3 altrimenti (expr1 è falsa).? ha una priorità maggiore dell operatore di assegnamento. v = (x == y)? 39 : 7 y = x < 5? 1 : 2; y = x? x : 0; y = ++x? x : x--; y = (x + 1)? x : 0; Y = (1 && 0)? (0 1) :!1;

30 Gerarchia finale

31 Operatori bitwise Operatore bi-a-bit Significato & AND &= AND con assegnamento OR = OR con assegnamento ^ XOR ^= XOR con assegnamento ~ Complemento a uno << Shift a sinistra >> Shift a destra <<= Shift a Sinistra con assegnamento >>= Shift a Destra con assegnamento

32 Operatori bitwise unsigned int a = 60; /* 60 = */ unsigned int b = 13; /* 13 = */ unsigned int c = 0; c = a & b; /* 12 = */ c = a b; /* 61 = */ c = a ^ b; /* 49 = */ c = c ~ c; /* 206 = */ unsigned int Value=4; /* 4 = */ unsigned int Shift=2; Value = Value << Shift; /* 16 = */ Value <<= Shift; /* 64 = */ Value = Value >> Shift * 2; /* 4 = */ // uno shift >> significa dividere per 2 // uno shift << significa moltiplicare per 2

33 Altri operatori Operatore & * sizeof Significato Restituisce l indirizzo dell operando. Accede tramite puntatore al contenuto della variabile puntata. Restituisce la lunghezza in byte dell operando. Esiste l analoga funzione sizeof(). Accede ai membri delle strutture. -> Accesso tramite puntatore ad un membro di una struttura. [] Operatore per accedere agli elementi di un array. {} Delimitatore di istruzioni.

34 Cast

35 Conversione di tipo (casting) Nelle operazioni tra tipi diversi, il C esegue una conversione automatica (implicita) Regola 1: gli operandi di tipo inferiore sono convertiti nell operando di tipo superiore. Il risultato è sempre di tipo superiore Regola 2: negli assegnamenti, il valore a destra viene convertito nel tipo a sinistra. int y = ; // warning del compilatore int x = 280; char ch; float f = 4.976; ch = x; x = f; f = x; // int convertito in char i 24 bitsuperiori di x vengono ignorati // float viene convertito in int, x ricevela parte intera di f //stesso valore ma in virgola mobile x = x + f; // quante conversioni vengono effettuate?

36 Conversione di tipo (casting): esplicito La conversione esplicita dei tipi avviene per mezzo di casting esplicito: (tipo) espressione Esempio: La funzione sqrt (calcola la radice quadrata del suo argomento) opera su double. #include <math.h> double sqrt(double x); Per n intero, possiamo scrivere sqrt((double) n) ma è ridondante perché? Nell'esempio di prima x = x + f si poteva scrivere x = x + ((int) f) char c = A ; printf( %d, (int) c)