Linguaggi di Programmazione (AA 2002/2003)

1. Linguaggi di Programmazione (AA 2002/2003) Corso di Laurea in Informatica Gabriella Pasi

2. PROGRAMMAZIONE A OGGETTI • Incapsulamanto dei dati • i dettagli di definizione di oggetti sono nascosti, solo le interfacce con l’esterno sono visibili • Ereditarietà • Gli oggetti sono definiti in una gerarchia ed ereditano dall’immediato parente caratteristiche comuni, che possono essere specializzate • Astrazione • Il meccanismo con cui si specificano le caratteristiche peculiari di un oggetto • Polimorfismo • Possibilità di definire funzioni con lo stesso nome che pure sono state specializzate per una particolare classe

3. JAVA Java è un linguaggio di programmazione ad alto livello creato dalla Sun Microsystems nel 1995 Java è un linguaggio orientato ad oggetti molto simile al C++, rispetto al quale risulta più semplificato allo scopo di prevenire gli errori di programmazione più comuni. Il codice sorgente in Java (con estensione .java) è compilato in un formato chiamato bytecode (estensione .class), che può essere eseguito da un interprete Java. Il bytecode può essere eseguito su differenti architetture di calcolo dato che esistono interpreti ed ambienti di esecuzione Java (Virtual Machines o VMs) per la maggior parte dei sistemi operativi.

4. JAVA • Il compilatore Java traduce il programma sorgente in una rappresentazione speciale detta bytecode • Il bytecode Java non è un linguaggio macchina di una CPU particolare, ma di una macchina virtuale Java • L’interprete traduce il bytecode nel linguaggio macchina e lo esegue • Un compilatore Java compiler non è legato ad una particolare macchina • Java è indipendente dall’architettura della macchina

5. JAVA codice sergente Java bytecode Java compilatore Java interprete Java compilatore Bytecode codice macchina

6. JAVA: Tipi di dati primitivi.

7. INTRODUZIONE AL LINGUAGGIO C • Linguaggio C • è basato sul paradigma imperativo • è di alto livello; • permette di vedere anche dettagli di basso livello del calcolatore; • è compilato; • Linguaggio Java • è basato sul paradigma a oggetti; • è di alto livello; • non è in grado di vedere direttamente i dettagli di basso livello del calcolatore; • è interpretato; • l'interprete (macchina virtuale) non e in grado di leggere direttamente il programma, ma legge un file in formato intermedio indipendente dall'architettura (bytecode) che si ottiene tramite compilazione del file sorgente.

8. INTRODUZIONE AL LINGUAGGIO C • Poiché il C NON E’ un linguaggio orientato a oggetti, NON APPLICAi seguenti concetti: • Classi • Oggetti • Istanzanziazione • Costruttori • Ereditarietà • Metodi • Overloading • public/private/protected

9. ALCUNI SITI UTILI SUL LINGUAGGIO C TUTORIAL SU C http://www.lysator.liu.se/c/bwk-tutor.html http://www-math.unice.fr/laboratoire/help/C/ctutor/node1.html JAVA - C http://www.cs.cornell.edu/courses/cs414/2001SP/tutorials/cforjava.htm

10. Struttura di un programma: differenza concettuale Un programma JAVA è costituito da una collezione di classi. Una classe, che contiene il metodo “main”, è la classe iniziale. Una classe definisce in modo astratto una categoria di oggetti, definendone sia la struttura sia le operazioni su di essi lecite. Un programma C è costituito da una collezione di funzioni. Non esiste il concetto di classe come categoria di oggetti. Una funzione C è una collezione di “statement”, che includono chiamate ad altre funzioni, e ha gli stessi costrutti standard quali gli statement if, i cicli while e for, ecc. Questi ultimi sono espressi come in Java.

12. ALCUNE DIFFERENZE TRA JAVA E C • “namespace” unico per funzioni e variabili globali Ogni classe in Java definisce uno spazio di nomi (spacename): questo permette di definire funzioni e variabili con lo stesso nome in classi distinte. Quando si identifica una funzione o una variabile in Java è necessario esprimere lo spacename. In C, tutte le funzioni sono globali e occorre condividere uno spazio di nomi unico (uno per programma). Anche le variabili globali fanno parte dello spacename condiviso. NB: in C esistono altri spazi di nomi: uno spazio di nomi unico è condiviso da una struttura, da un’unione o da una enumerazione. Ogni blocco ha uno spazio di nomi per le variabili locali In C le funzioni devono avere nomi diversi, indipendentemente dai loro argomenti

13. ALCUNE DIFFERENZE TRA JAVA E C • I programmi Java possono essere più semplici da sviluppare poichè: • la gestione dinamica della memoria è prevalentemente automatica • sono effettuati controlli di illegalità di operazioni (ad esempio oltrepassare i limiti di un array). • I programmi C hanno tipicamente un’esecuzione più veloce, poichè: • la gestione dinamica della memoria (che spesso non è richiesta) è completamente controllata dal programmatore • non ci sono controlli di illegalità di operazioni (maggiore attenzione nella scrittura da parte dei programmatori), • maggiore responsabilità da parte del programmatore C

14. ESEMPIO DI PROGRAMMA C #include <stdio.h> void main(void) { printf(“Hello World. \n \t and you ! \n ”); /* stampa di un messaggio */ return; } $Hello World. and you ! $

15. ESEMPIO DI PROGRAMMA C • #include <stdio.h> = include il file di libreria stdio.h • senza punto e virgola alla fine • solo lettere minuscole – il C è case-sensitive • void main(void){ … } è il solo codice eseguito • printf(“ /* messaggio che si desidera stampare */ ”); • \n = a capo \t = tab • Il simbolo \ prima di caratteri speciali in printf. • printf(“Have you heard of \”The Rock\” ? \n”);

16. COMMENTI JAVA /* commento su più linee …….. */ // commento su linea singola C /* soltanto commento su più linee …….. */

17. public class FooBar {public static void main(String [] args) {System.out.println("Hello world\n");}} public class FooBar {public static void main(String [] args) {System.out.printfln("Hello world\n");}}

18. TIPI DI DATI SEMPLICI • Tipo di dato # bytes(typical) valori notaz.breve • int               4      da -2,147,483,648 a 2,147,483,647 %d • char              1       da -128 a 127 %c • float             4       3.4E+/-38 (7 cifre) %f • double            8       1.7E+/-308 (15 cifre) %lf • long              4      da -2,147,483,648 a 2,147,483,647 %l • short             2      da -32,768 a 32,767 • modificatori: • signed / unsigned - int, char, long, short • long double • ex: • int num=20000; • printf(“Cornell has about %d students.\n”, num);

19. TIPI PRIMITIVI Dimensioni: le dimensioni tipiche e l'intervallo di valori per i tipi fondamentali di dati dipendono dall’architettura della macchina utilizzata Nel caso di un'architettura a 32 bit:

20. TIPI PRIMITIVI

21. C: TIPI PRIMITIVI • I modicatori di tipo che si applicano ai tipi interi char e int sono • signed: con segno; • unsigned: senza segno; • long: maggior estensione; • short: minor estensione; • char: carattere ASCII; • int: intero; • float: virgola mobile; • double: virgola mobile doppia precisione; • void: nessun valore/qualunque tipo. Come in Java, le funzioni C functions che non “producono” un valore restituiscono void. A differenza del Java, una funzione C senza parametri ha void nella sua lista di parametri. NOTA BENE: non esiste tipo boolean. Le condizioni espresse in espressioni condizionali e iterative, e gli operandi di operatori logici (!, && e ||), sono espressioni intere con una interpretazione booleana:zero significa falso, non-zero significa vero. Gli operatori relazionali (= =, !=, <=, >=, < e >) e gli operatori logici restituiscono 0 per falso e 1 per vero.

22. ESEMPIO 2 DI PROGRAMMA C #include <stdio.h> void main(void) { int nstudents = 0; /* inizializzazione, richiesta */ printf(“How many students does Cornell have ?:”); scanf (“%d”, &nstudents); /* Read input */ printf(“Cornell has %d students.\n”, nstudents); return ; } $How many students does Cornell have ?: 20000 (enter) Cornell has 20000 students. $

23. CONVERSIONE DI TIPI Cast: permette di forzare un'espressione perchè sia di un tipo specifico. (tipo) espressione; ATTENZIONE: il cast inibisce il controllo sui tipi da parte del compilatore! Es.: int i, j; float x = 123.4e10; i = x, il compilatore avverte che i due tipi sono diversi; j = (int) x, nessun avvertimento!! #include <stdio.h> void main(void) { int i,j = 12; /* i non è inizializzato, solo j */ float f1,f2 = 1.2; i = (int) f2; /* i <- 1, 0.2 perso */ f1 = i; /* f1 <- 1.0 */ f1 = f2 + (int) j; /* f1 <- 1.2 + 12.0 */ f1 = f2 + j; /* f1 <- 1.2 + 12.0 */ }

24. ISTRUZIONE printf

25. ISTRUZIONE printf

26. ISTRUZIONE printf

27. ISTRUZIONE printf

28. ISTRUZIONE printf

29. ISTRUZIONE printf

30. JAVA E C: ASPETTI SIMILI • Operatori in C uguali a quelli in Java: • Aritmetici • int i = i+1; i++; i--; i *= 2; • +, -, *, /, %, • Relazionali e Logici • <, >, <=, >=, ==, != • &&, ||, &, |, ! • Sintassi come in Java: • if ( ) { } else { } • while ( ) { } • do { } while ( ); • for(i=1; i <= 100; i++) { } • switch ( ) {case 1: … } • continue; break;

31. ESEMPIO • #include <stdio.h> • #define DANGERLEVEL 5 /* C Preprocessor - • - sostituzione quando appare */ • /* come final in Java final tipo nome [valore] */ • void main(void) • { • float level=1; • /* if-then-else come in Java */ • if (level <= DANGERLEVEL){ /*sostituito da 5*/ • printf(“livello basso!\n”); • } • else printf(“bene !\n”); • return; • }

32. NOTAZIONI CRIPTICHE • int x = 0,y = 2,z = 1025; • float a = 0.0,b = 3.14159,c = -37.234; • x = x + 1; /* incrementa x */ • x++; /* incrementa x */ • ++x; /* incrementa x */ • z = y++; /* z = 2, y = 3 */ • z = ++y; /* z = 4, y = 4 */ • y = y - 1; /* decrementa y */ • y--; /* decrementa y */ • --y; /* decrementa y */ • y = 3; • z = y--; /* z = 3, y = 2 */ • z = --y; /* z = 1, y = 1 */ • a = a + 12; /* aggiunge 12 ad a */ • a += 12; /* aggiunge 12 ad a */ • a *= 3.2; /* moltiplica a per 3.2 */ • a -= b; /* sottrae b ad a */ • a /= 10.0; /* divide a per 10.0 */

33. ARRAY MONODIMENSIONALI #include <stdio.h> void main(void) { int number[12]; /* 12 celle, una cella per studente */ int index, sum = 0; /* inizializzare sempre un array prima dell’uso */ for (index = 0; index < 12; index++) { number[index] = index; } /* ora, number[index]=index; causerebbe un errore */ for (index = 0; index < 12; index = index + 1) { sum += number[index]; /* somma gli elementi dell’array */ } return; }

34. JAVA: ARRAY La dichiarazione di un array avviene in Java senza l'indicazione esplicita del numero di elementi. La dichiarazione avviene come se si trattasse di un tipo di dati normale, con la differenza che si aggiungono una coppia di parentesi quadre a sottolineare che si tratta di un array di elementi di quel tipo. int[] arrayDiInteri; Per fare in modo che l'array esista effettivamente, occorre che questo sia inizializzato, fornendogli gli elementi. Si usa per questo l'operatore new seguito dal tipo di dati con il numero di elementi racchiuso tra parentesi quadre. Per esempio, arrayDiInteri = new int[7];

35. ARRAY IN C • Stringhe char nome[6]; nome = {‘C’,’S’,’4’,’1’,’4’,’\0’}; /* ’\0’= end of string */ printf(“%s”, nome); /* stampa fino a ‘\0’ */ • Funzioni che permettono di operare su stringhe • strcpy, strncpy, strcmp, strncmp, strcat, strncat, strstr,strchr • #include <strings.h> at program start • Array multidimensionali int points[3][4]; points [1][3] = 12; /* NON points[3,4] !*/ printf(“%d”, points[1][3]);

36. STRINGHE main() { char name[5]; /* definisce una stringa di caratteri */ name[0] = 'D'; name[1] = ’o'; name[2] = 'v'; name[3] = 'e'; name[4] = 0; /* end of text */ printf(”Il nome è %s\n",nome); printf(”una lettera è %c\n",name[2]); }

37. JAVA: stringhe Le stringhe in Java sono oggetti, e in particolare se ne distinguono due tipi: stringhe costanti e stringhe variabili. La distinzione è utile perché questi due tipi di oggetti hanno bisogno di una forma di rappresentazione diversa. Dichiarazione: String variabile; La creazione dell'oggetto si ottiene utilizzando l'operatore new. new String (stringa);

38. STRINGHE char name1[12],name2[12],mixed[25]; char title[20]; strcpy(name1,"Rosalinda"); strcpy(name2,"Zeke"); if(strcmp(name1,name2)>0) /* returns 1 if name1 > name2 */ strcpy(mixed,name1); else strcpy(mixed,name2); strcat(mixed,name2);

39. Conversione di tipi • attenzione con la conversione di tipi • c = (char) some_int; • Arrays • Sempre inizializzare prima di usarli • int number[12]; printf(“%d”, number[20]); • produce un output indefinito, può terminare, può persino non essere segnalato. • Le stringhe sono terminate dalla sequenza by ’\0’ char name[6] = {‘C’,’S’,’4’,’1’,’4’,’\0’}; /* ’\0’= end of string */ printf(“%s”, name); /* stampa sino a ‘\0’ */

40. CLASSI E STRUTTURE Il C non permette di creare classi (a questo scopo in Java si usa il costrutto class). Il concetto di classe NON ESISTE in C. Tuttavia in C si possono creare strutture per mezzo del costrutto struct. Una struttura C non contiene funzioni(metodi). Tutte le parti di una struct sono visibili ad ogni porzione di codice che conosce la dichiarazione. struct point { int x; int y; }; struct point { int x, y; }; Con la definizione struct si crea un nuovo tipo dato (tipo di dato creato dall’utente)

41. STRUTTURE • Insieme di variabili • cui si fa riferimento con un unico nome • si mantengono unite informazioni correlate • concetto logico di record nuovo tipo dato

42. STRUTTURE Dopo avere definito il tipo si possono dichiarare elementi di questo tipo: struct point pt; struct ind indirizzo; E’ possibile creare il tipo dato e dichiararne le variabili in un unico passaggio

43. STRUTTURE Inizializzazione di un elemento: struct point pt = {300,33}; Accesso ai vari elementi di una struttura attraverso l’operatore. (punto) - come in Java: struct point location; location.x = 10; location.y = 13;

44. STRUTTURE A differenza del Java, dove le variabili di una classe sono riferimenti a oggetti, in C le variabili di tipo struttura sono gli oggetti stessi. L’assegnamento di strutture causa la copiatura dei membri : struct point a = { 1, 2 }; struct point b; b = a; /* copia a.x in b.x, e a.y in b.y */ b.x = 10; /* non agisce su a.x */

45. STRUTTURE #include <stdio.h> struct birthday{ int month; int day; int year; }; main() { struct birthday mybday; /* new non è necessario ! */ /* quindi, è soltanto simile a Java ! */ mybday.day=1; mybday.month=1; mybday.year=1977; printf(“Sono nato il %d/%d/%d”, mybday.day, mybday.month, mybday.year); }

46. PUNTATORI In Java tutte le variabili di tipi non primitivi sono riferimenti. Il C non realizza il concetto di ‘riferimento’, ma ha invece i puntatori, che il Java non ha. Un puntatore è l’indirizzo in memoria di un dato. Una variabile può essere di tipo puntatore, in tal caso essa contiene l’indirizzo di un dato in memoria. /* assumiamo di essere all’interno di un blocco*/ int i, j; /* i e j sono variabili intere */ int *ip; /* ip è una variabile che può puntare una variabile intera */ i = 10; j = 20; /* assegnamento di valori */ ip = &i; /* ip punta a i */ *ip = 5; /* assegnamento indiretto di 5 a i */ ip = &j; /* ip punta a j */ *ip += 7; /* j ora contiene 27 */ i += *ip; /* i ora contiene 32 */

47. PUNTATORI, esempio int x = 5, y = 10; float f = 12.5, g = 9.8; char c = ‘c’, d = ‘d’; 5 10 12.5 9. 8 c d 4300 4304 4308 4312 4316 4317

48. any float f f_addr ? ? ? any address 4300 4304 f f_addr ? 4300 4300 4304 PUNTATORI Puntatore = variable contenente l’indirizzo di un’altra variabile float f; /* variabile numerica */ float *f_addr; /* variabile di tipo puntatore */ f_addr = &f; /* & = operatore indirizzo */

49. PUNTATORI f f_addr 3.2 1.3 4300 4300 4300 4304 f f_addr 4300 4304 *f_addr = 3.2; /* assegnamento indiretto */ float g=*f_addr; /* assegnamento indiretto: g vale 3.2*/ f = 1.3;

50. PUNTATORI - ESEMPIO #include <stdio.h> void main(void) { int j; int *ptr; ptr=&j; /* inizializza ptr prima di usarlo */ /* *ptr=4 non inizializza ptr! */ *ptr=4; /* j <- 4 */ j=*ptr; /* j <- ??? */ }