Linguaggi di Programmazione (AA 2002/2003)
description
Transcript of Linguaggi di Programmazione (AA 2002/2003)
Linguaggi di ProgrammazioneLinguaggi di Programmazione(AA 2002/2003)(AA 2002/2003)
Corso di Laurea in InformaticaCorso di Laurea in Informatica
Gabriella PasiGabriella Pasi
• Incapsulamanto dei datiIncapsulamanto dei dati– i dettagli di definizione di oggetti sono nascosti, solo le interfacce con
l’esterno sono visibili
• EreditarietàEreditarietà– Gli oggetti sono definiti in una gerarchia ed ereditano dall’immediato
parente caratteristiche comuni, che possono essere specializzate
• AstrazioneAstrazione– Il meccanismo con cui si specificano le caratteristiche peculiari di un
oggetto
• PolimorfismoPolimorfismo– Possibilità di definire funzioni con lo stesso nome che pure sono state
specializzate per una particolare classe
PROGRAMMAZIONE A OGGETTIPROGRAMMAZIONE A OGGETTI
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.
JAVAJAVA
JAVAJAVA
• Il compilatore Java traduce il programma sorgentesorgente in una rappresentazione speciale detta bytecodebytecode
• Il bytecode Java non è un linguaggio macchina di una CPU particolare, ma di una macchina virtuale Javamacchina 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
codice sergenteJava
codicemacchina
bytecode Java
interpreteJava
compilatoreBytecode
compilatoreJava
JAVAJAVA
JAVA: Tipi di dati primitivi.JAVA: Tipi di dati primitivi.
Tipo Dimensione Descrizionebyte 8 bit, complemento a due. Intero a 8 bit.short 16 bit, complemento a due. Intero ridotto.int 32 bit, complemento a due. Intero normale.long 64 bit, complemento a due. Intero molto grande.float 32 bit Virgola mobile, singola precisione.double 64 bit Virgola mobile, doppia precisione.char 16 bit, carattere Unicode. Carattere.boolean Vero o Falso. Valore booleano.
Linguaggio CLinguaggio C• è basato sul paradigma imperativo• è di alto livello;• permette di vedere anche dettagli di basso livello del calcolatore;• è compilato;
Linguaggio JavaLinguaggio 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.
INTRODUZIONE AL LINGUAGGIO CINTRODUZIONE AL LINGUAGGIO C
Poiché il C NON E’NON E’ un linguaggio orientato a oggetti, NON APPLICANON APPLICA i seguenti concetti:
Classi
Oggetti
Istanzanziazione
Costruttori
Ereditarietà
Metodi
Overloading
public/private/protected
INTRODUZIONE AL LINGUAGGIO CINTRODUZIONE AL LINGUAGGIO C
ALCUNI SITI UTILI SUL LINGUAGGIO CALCUNI SITI UTILI SUL LINGUAGGIO C
http://www.lysator.liu.se/c/bwk-tutor.html
http://www-math.unice.fr/laboratoire/help/C/ctutor/node1.html
http://www.cs.cornell.edu/courses/cs414/2001SP/tutorials/cforjava.htm
TUTORIAL SU CTUTORIAL SU C
JAVA - CJAVA - C
Struttura di un programma:Struttura di un programma:differenza concettualedifferenza 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.
““namespace” unico per funzioni e variabili globalinamespace” unico per funzioni e variabili globaliOgni classe in Javain 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 CIn 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
ALCUNE DIFFERENZE TRA JAVA E CALCUNE DIFFERENZE TRA JAVA E C
ALCUNE DIFFERENZE TRA JAVA E CALCUNE 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 Cmaggiore responsabilità da parte del programmatore C
#include <stdio.h>
void main(void){ printf(“Hello World. \n \t and you ! \n ”);
/* stampa di un messaggio */ return;}
$Hello World.and you !
$
ESEMPIO DI PROGRAMMA CESEMPIO 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”);
ESEMPIO DI PROGRAMMA CESEMPIO DI PROGRAMMA C
COMMENTICOMMENTI
/* commento su più
linee …….. */
// commento su linea singola
JAVAJAVA
CC
/* soltanto commento su più
linee …….. */
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");}}
• 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);
•
TIPI DI DATI SEMPLICITIPI DI DATI SEMPLICI
Dimensioni: le dimensioni tipiche e l'intervallo di valori per i tipi fondamentali di dati dipendono dall’architettura della macchina utilizzata
TIPI PRIMITIVITIPI PRIMITIVI
Nel caso di un'architettura a 32 bit:
TIPI PRIMITIVITIPI PRIMITIVI
C: TIPI PRIMITIVIC: TIPI PRIMITIVI
• char: carattere ASCII;• int: intero;• float: virgola mobile;• double: virgola mobile
doppia precisione;• void: nessun
valore/qualunque tipo.
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;
NOTA BENE: non esiste tipo booleanboolean. 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.
Come in JavaCome in Java, le funzioni C functions che non “producono” un valore restituiscono void. A differenza del JavaA differenza del Java, una funzione C senza parametri ha void nella sua lista di parametri.
#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.$
ESEMPIO 2 DI PROGRAMMA CESEMPIO 2 DI PROGRAMMA C
#include <stdio.h>#include <stdio.h>void main(void)void main(void){{
int i,j = 12; /* i non è inizializzato, solo j */int i,j = 12; /* i non è inizializzato, solo j */float f1,f2 = 1.2;float f1,f2 = 1.2;
i = (int) f2; /* i <- 1, 0.2 perso */i = (int) f2; /* i <- 1, 0.2 perso */f1 = i; /* f1 <- 1.0 */f1 = i; /* f1 <- 1.0 */
f1 = f2 + (int) j; /* f1 <- 1.2 + 12.0 */f1 = f2 + (int) j; /* f1 <- 1.2 + 12.0 */f1 = f2 + j; /* f1 <- 1.2 + 12.0 */f1 = f2 + j; /* f1 <- 1.2 + 12.0 */
}}
CONVERSIONE DI TIPICONVERSIONE DI TIPI
CastCast: permette di forzare un'espressione perchè sia di un tipo specifico.
(tipo) espressione;ATTENZIONEATTENZIONE: 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!!
ISTRUZIONE printfISTRUZIONE printf
ISTRUZIONE printfISTRUZIONE printf
ISTRUZIONE printfISTRUZIONE printf
ISTRUZIONE printfISTRUZIONE printf
ISTRUZIONE printfISTRUZIONE printf
ISTRUZIONE printfISTRUZIONE printf
• Operatori in C uguali a quelli in JavaOperatori in C uguali a quelli in Java: • AritmeticiAritmetici
• int i = i+1; i++; i--; i *= 2;• +, -, *, /, %,
• Relazionali e LogiciRelazionali e Logici • <, >, <=, >=, ==, !=• &&, ||, &, |, !
• Sintassi come in JavaSintassi come in Java:• if ( ) { } else { }• while ( ) { }• do { } while ( );• for(i=1; i <= 100; i++) { }• switch ( ) {case 1: … }• continue; break;
JAVA E C: ASPETTI SIMILIJAVA E C: ASPETTI SIMILI
#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;}
ESEMPIOESEMPIO
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 */
NOTAZIONI CRIPTICHENOTAZIONI CRIPTICHE
#include <stdio.h>
void main(void) { int number[12]; /* 12 celle, una cella per studente */ int index, sum = 0; /* inizializzare inizializzare sempresempre un array prima dell’uso un array prima dell’uso */ for (index = 0; index < 12; index++) {
number[index] = index; } /* ora, number[index]=index; causerebbe un erroreora, number[index]=index; causerebbe un errore */
for (index = 0; index < 12; index = index + 1) {sum += number[index];
/* somma gli elementi dell’array */ }
return;}
ARRAY MONODIMENSIONALIARRAY MONODIMENSIONALI
La dichiarazione di un array avviene in Java senza La dichiarazione di un array avviene in Java senza l'indicazione esplicita del numero di elementil'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];
JAVA: ARRAYJAVA: ARRAY
• Stringhechar 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]);
ARRAY IN CARRAY IN C
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]);}
STRINGHESTRINGHE
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.
DichiarazioneDichiarazione:
String variabile;
La creazione dell'oggetto si ottiene utilizzando l'operatore new.
new String (stringa);
JAVA: stringheJAVA: 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);
STRINGHESTRINGHE
• 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’ */
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 structstruct. Una struttura C non contiene funzioni(metodi). Tutte le parti di una struct sono visibili ad ogni porzione di codice che conosce la dichiarazione.
CLASSI E STRUTTURECLASSI E STRUTTURE
struct point { int x, y;};
struct point { int x; int y;};
Con la definizione struct si crea un nuovo tipo dato (tipo di dato creato dall’utente)
• Insieme di variabiliInsieme di variabili – cui si fa riferimento con un unico nome– si mantengono unite informazioni correlate– concetto logico di record
nuovo tipo dato
STRUTTURESTRUTTURE
STRUTTURESTRUTTURE
Dopo avere definito il tipo si possono dichiarare elementi di questo tipo:
struct ind indirizzo; struct point pt;
E’ possibile creare il tipo dato e dichiararne le variabili in un unico passaggio
STRUTTURESTRUTTURE
Inizializzazione di un elementoInizializzazione di un elemento::
struct point pt = {300,33};
Accesso ai vari elementi di una struttura attraverso Accesso ai vari elementi di una struttura attraverso l’operatore. (punto) - l’operatore. (punto) - come in Javacome in Java::
struct point location;
location.x = 10;
location.y = 13;
A differenza del Java, dove le variabili di una classe sono riferimenti a oggetti, in C le variabili di tipo struttura sono gli oggetti stessiin 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 */
STRUTTURESTRUTTURE
#include <stdio.h>
struct birthday{ int month; int day; int year; };
main() { struct birthday mybday; /* new non è necessarionew non è necessario ! */ /* quindi, è quindi, è soltanto similesoltanto simile a Java a Java ! */ mybday.day=1; mybday.month=1; mybday.year=1977; printf(“Sono nato il %d/%d/%d”, mybday.day, mybday.month, mybday.year);}
STRUTTURESTRUTTURE
PUNTATORIPUNTATORIIn 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 */
5 10 12.5 9. 8 c d
int x = 5, y = 10;float f = 12.5, g = 9.8;char c = ‘c’, d = ‘d’;
4300 4304 4308 4312 4316 4317
PUNTATORI, esempioPUNTATORI, esempio
Puntatore = variable contenente l’indirizzo di un’altra variabile float f; /* variabile numerica */
float *f_addr; /* variabile di tipo puntatore */
f_addr = &f; /* & = operatore indirizzooperatore indirizzo */
? ?
f f_addr
4300 4304
?
any float
any address
? 4300
f f_addr
4300 4304
PUNTATORIPUNTATORI
*f_addr = 3.2; /* assegnamento indiretto */
f f_addr
4300 4304
3.2 4300
f f_addr
4300 4304
1.3 4300
PUNTATORIPUNTATORI
float g=*f_addr;
/* assegnamento indiretto: g vale 3.2*/
f = 1.3;
#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 <- ??? */}
PUNTATORI - ESEMPIOPUNTATORI - ESEMPIO
I programmi C sono costituiti di collezioni di due tipi di elementi:
• funzioni (hanno un comportamento) e
• entità - oggetti (hanno valori; le variabili sono delle entità).
Dichiarazioni e definizioniDichiarazioni e definizioni
Un compilatore C legge un file sorgente in modo sequenziale, cercando i nomi di tipi, variabili e funzioni.
La dichiarazione di un tipo, oggetto e funzione comunica al compilatore l’esistenza di un nome e di come esso potrà essere usato più avanti nel file. Se il compilatore incontra un nome che non è stato già dichiarato, vi è la generazione di un errore.
La definizione di una variabile può anche indicare il suo valore iniziale; la definizione di una funzione specifica il suo comportamento.
In Java, l’uso di una funzione può apparire prima della sua definizione. In C, tutte le funzioni utilizzate nel file sorgente devono essere dichiarate prima dell’invocazione nel file, permettendo cosi’ al compilatore un controllo della correttezza degli argomenti rispetto alla definizione dei parametri formali della funzione.
FUNZIONIFUNZIONI
Una dichiarazione di funzione (o prototipo) è simile alla definizione della funzione, ma il suo corpo (il codice tra gli statement { e }) è sostituito da un ;. Se il compilatore trova una invocazione di funzione prima di una dichiarazione, cercherà di inferire una dichiarazione dall’invocazione, e questo può produrre errori.
I programmi Java sono costruiti in modo modulare, anche per favorire il riutilizzo del codice.
Il codice sorgente è diviso in molti file sorgente (.java), ed è usato per generare dei file byte-code di tipo classe (.class).
In Java, esiste una relazione diretta tra il nome di una classe e il file contenente il codice di quella classe. Questi file sono combinati durante l’esecuzione (run-time) per produrre il programma in esecuzione.
MODULARITÀ DEI PROGRAMMIMODULARITÀ DEI PROGRAMMI
Anche un grosso programma C può essere diviso in molti file sorgente (solitamente con estensione .c), la cui compilazione produce distinti file di tipo oggetto che (solitamente) hanno lo stesso nome con una diversa estensione (.o o .obj). Questi costituiscono moduli di C che possono essere combinati per ottenere un programma eseguibile. Un file oggetto contiene le rappresentazioni con nome associato delle funzioni e delle variabili globali definite nel suo file sorgente, e permette un riferimento ad altre funzioni e dati globali per mezzo del loro nome, anche se risiedono in moduli separati.
In C, non esiste alcuna relazione tra i nomi di funzioni e variabili e i nomi dei moduli che li contengono.
MODULARITÀ DEI PROGRAMMIMODULARITÀ DEI PROGRAMMI
Il programma eseguibile finale è prodotto per mezzo di un linker
(spesso definito all’interno del compilatore) che collega tutti i
moduli rilevanti (file oggetto). Il linker cerca di risolvere tutti i nomi
a cui si fa riferimento nei moduli in indirizzi di memoria richiesti dal
codice macchina generato. Il linking fallisce se alcuni nomi non
possono essere risolti, o se ci sono due rappresentazioni con lo
stesso nome.
MODULARITÀ DEI PROGRAMMIMODULARITÀ DEI PROGRAMMI
• Gli argomenti possono essere passati a una funzione– per valore
– per riferimento
• I valori prodotti da una funzione possono essere– per valore
– per riferimento
FUNZIONIFUNZIONI
#include <stdio.h>int sum(int a, int b);
/* prototipo della funzione all’inizio del prototipo della funzione all’inizio del filefile */
void main(void){ int total = sum(4,5); /* chiamata alla funzione */
printf(“La somma di 4 e 5 è %d”, total);}
int sum(int a, int b){ /* definizione della funzione - argomenti passati per valore */
return (a+b); /* return per valore */}
FUNZIONI: ESEMPIO 1FUNZIONI: ESEMPIO 1
#include <stdio.h>int sum(int *pa, int *pb);
/* prototipo della funzione all’inizio del file */
void main(void){ int a=4, b=5; int *ptr = &b; int total = sum(&a,ptr); /* chiamata alla funzione */
printf(“La somma di 4 e 5 è %d”, total);}
int sum(int *pa, int *pb){/* definizione della funzione - argomenti passati per riferimento */
return (*pa+*pb); /* return per valore */}
FUNZIONI: ESEMPIO 2FUNZIONI: ESEMPIO 2
#include <stdio.h>
void init_array(int array[], int size) ;
void main(void) { int list[5];
init_array(list, 5); for (i = 0; i < 5; i++) printf(“next:%d”, list[i]);}
void init_array(int array[], int size) { /* gli array sono SEMPRE passati per riferimento */ int i; for (i = 0; i < size; i++) array[i] = 0; }
FUNZIONI: ESEMPIO 3 (passaggio di array)FUNZIONI: ESEMPIO 3 (passaggio di array)
FUNZIONI: ESEMPIO 4 (passaggio di array e FUNZIONI: ESEMPIO 4 (passaggio di array e aritmentica dei puntatori)aritmentica dei puntatori)
int maxMin (double arr [ ], int size, double *max, double *min){if ( arr == NULL || size<= 0)
return 0;for (*max = *min = arr[0], p = arr +1; p < arr + size; p++){if (*max < *p)
*max = *p; funzione che calcola il min ed il maxif (*min > *p) passando tutti i parametri per
riferimento*mim = *p, tranne size
}return 1}
ALLOCAZIONE DINAMICA DELLA MEMORIAALLOCAZIONE DINAMICA DELLA MEMORIA
L'allocazione dinamica permette di creare tipi di dati e creare tipi di dati e strutture di qualsiasi dimensione e lunghezza in modo strutture di qualsiasi dimensione e lunghezza in modo dinamicodinamico.
Tra gli utilizzi più diffusi:
definizione di array dinamicidefinizione di array dinamici;
strutture dinamiche di dati, ad es. “linked list”strutture dinamiche di dati, ad es. “linked list”.
#include <stdio.h>
void main(void) {int *ptr;
/* alloca spazio per contenere un intero */ptr = (int *)malloc(sizeof(int));
/* fa qualcosa con lo spazio definito */*ptr=4;
free(ptr);/* libera lo sapeio allocato */
}
• Allocazione e de-allocazione esplicita
ALLOCAZIONE DINAMICA DELLA MEMORIAALLOCAZIONE DINAMICA DELLA MEMORIA
Header info
Code
Data - Heap
0
100
400
560
1010
1200
Memoria dinamicaMemoria dinamica
Stack diStack dimemoria localememoria locale+ chiamate di + chiamate di funzionifunzioni
Tutte le var
Tutte le malloc()
Data - stack
STRUTTURA DELLA MEMORIA STRUTTURA DELLA MEMORIA PER UN PROGRAMMAPER UN PROGRAMMA
La funzione mallocmalloc è predefinita come:
char *malloc(int numero_di_byte)
Questa funzione ritorna un puntatore a carattere che corrisponde al punto di inizio in memoria della porzione riservata di dimensione ”numero_di_byte". Se la memoria richiesta non puo' essere allocata, ritorna un puntatore nullo.
ALLOCAZIONE DINAMICA DELLA MEMORIAALLOCAZIONE DINAMICA DELLA MEMORIA
Le funzioni malloc() e free() fanno parte di una libreria esterna e vengono utlizzate per allocare e liberare memoria quando ce n’è bisogno (allocazione dinamica).
Se si vuole avere un puntatore ad un altro tipo di dato, si deve utilizzare il “casting”:
puntatore = (tipo*) malloc(byte);…………...free(puntatore); Libera la memoria precedentemente
allocata
ALLOCAZIONE DINAMICA DELLA MEMORIAALLOCAZIONE DINAMICA DELLA MEMORIA
Solitamente viene utilizzata la funzione sizeof() per specificare il numero di bytes da allocare:
int *ip;
ip = (int *) malloc(sizeof(int));
Nel seguente esempio viene allocata/deallocata memoria per 10interi
int *pint;pint = (int*) malloc(10 * sizeof(int));free(p int);
"sizeof" puo' essere usata per trovare la dimensione di un qualsiasi tipo di dato, variabile o struttura; e' possibile farlo semplicemente passando uno di questi come argomento alla funzione.
Cosi':
int i;
struct COORD {float x,y,z};
sizeof(int), sizeof(i),
sizeof(struct COORD)
ALLOCAZIONE DINAMICA DELLA MEMORIAALLOCAZIONE DINAMICA DELLA MEMORIA
In molti casi il numero di elementi di un vettore/matrice può essere determinato solo durante l’esecuzione di un programma.Es: Supponiamo di voler ricevere in input un vettore. Il primo numero che viene dato è la dimensione di questo vettore, mentre i numeri successivi sono gli elementi.Usando i vettori statici avremmo bisogno di decidere a priori un numero massimo di elementi e ciò porrebbe dei grossi limiti all’applicabilità del nostro programma.
Usando la funzione malloc() possiamo decidere la dimensione del vettore durante l’esecuzione dl programma
Array dinamici
Array dinamici#include <stdio.h>#include <stdlib.h>#include <malloc.h> /*header file contenente la definizione di malloc */main(){
int *p; /* definiamo un putatatore ad intero */int dim,i;printf(“Inserire il numero di elementi del vettore:”);scanf(“%d”,&dim);p=(int *)malloc(dim*sizeof(int));
/* alloca dinamicamente una zona di memoria*/if ( p==NULL){/*verifica se l’allocazione è andata a buon fine */printf ("Errore: Memoria non disposnibile \n");exit(1);}for(i=0;i<dim;i++){
printf(“Inserire il valore dell’elemento %d del vettore:”,i);scanf(“%d”,&p[i]);
printf(“L’indirizzo di p[%d] e’:%x\n il suo valore e’*p=%d\n",i,p+i,p[i]);}free(p); //libera la memoria allocata
}
Per consentire la definizione di strutture dati ricorsive, ogni linguaggio deve fornire un modo per "riusare" il nome della struttura che si sta definendo dentro la definizione stessa.
typedef struct item {
int value;
struct item *next;
} listItem;
listItem *list;
così, si può fare riferimento alla struttura all'interno della sua stessa definizione, perché il tipo struct item è già noto al compilatore quando si entra nel blocco {...} etichettato item
Strutture dati ricorsive: liste
n1 n2 n3
la parola chiave la parola chiave typedeftypedef consente la denizione di nuovi consente la denizione di nuovi nomi di tipi di dati a partire da nomi di tipi di dati a partire da quelli esistentiquelli esistenti
Nuovo nome associato al tipo struct itemNuovo nome associato al tipo struct item
Strutture dati ricorsive: liste semplici
Strutture dati ricorsive: liste doppie
typedef struct item {
int value;
struct item *left, *right;
} node;
typedef node *tree;
Strutture dati ricorsive: alberi binari