Upload
pasquale-paola
View
51
Download
13
Embed Size (px)
DESCRIPTION
Short introduction to most popular programming languages
Citation preview
C/C++/JAVA
Refresh rapido
Cominciamo col C
Struttura di un programma C
/* This is a comment */// This is a one-line comment# include <stdio.h> /* includes header files */main() /* Must have a main function. First function {printf ("Hello World!"); /* stdio functions */}
Tipi
int - stores integers (-32767 to +32768) unsigned int – 0 to 65535 char – holds 1 byte of data (-127 to 128) unsigned char – holds 1 byte (0 to +255) long – usually double int (signed) unsigned long – positive double int float – floating point variable double – twice of a floating point variable
printf
printf (“%d”,i); Usual variable type Display
– %c char single character– %d (%i) int signed integer– %e (%E) float or double exponential format– %f float or double signed decimal– %g (%G) float or double use %f or %e as required– %o int unsigned octal value– %p pointer address stored in pointer– %s array of char sequence of characters– %u int unsigned decimal– %x (%X) int unsigned hex value
Operatori + addition - subtraction * multiplication / division % mod or remainder (e.g., 2%3 is 2), also called 'modulo' << left-shift (e.g., i<<j is i shifted to the left by j bits) >> right-shift & bitwise AND | bitwise OR ^ bitwise exclusive-OR && logical AND (returns 1 if both operands are non-zero; else 0) || logical OR (returns 1 if either operand is non-zero; else 0) < less than (e.g., i<j returns 1 if i is less than j) > greater than <= less than or equal >= greater than or equal == equals != does not equal
Incremento e decremento
++ Increment operator -- Decrement Operator k++ or k-- (Post-increment/decrement) k = 5; x = k++; // sets x to 5, then increments k to 6 ++k or --k (Pre-increment/decrement) k = 5; x = ++k; // increments k to 6 and then sets x
to the
// resulting value, i.e., to 6
Funzioni e prototipi
#include <stdio.h>int add1(int);void main(){int x;x=5;x=add1(x);printf("%d“,x);}int add1(int i){int y;y=i+1;return (y);}
Operatori sui bit
<< left shift >> right shift | bitwise OR & bitwise AND ^ bitwise XOR ~ bitwise NOT
Tabella di “verità”
Esempio shifting
Condizionali
if (expression) statementelse statement
while (expression) statement do statement while (expression) for( initialization; expression; increment )
statement switch (expression) { case item1: statement1; break; default: statement; break; }
Array
int x[10];double y[15];x[10]=10;char c[15];
Puntatori!!!
int a, *b, c; // b is a pointerb = &a; // Store in b the address of ac = *b; // Store in c the value at // address b (i.e., a)
Puntatori a caratteri e array
char *y;char x[100];y = &x[0];y = x; // Does the same as the line above*(y+1) gives x[1]*(y+i) gives x[i]
Ancora puntatori
int x,y;
int *p1,*p2;
1000
1004
1008
1012
x
y
p1
p2
Ancora puntatori(2)
x=-42;
y=163
1000
1004
1008
1012
x
y
p1
p2
-42
163
Ancora puntatori(3)
p1=&x;
p2=&y;
1000
1004
1008
1012
x
y
p1
p2
-42
163
1000
1004
Ancora puntatori(4)
*p1=17;
1000
1004
1008
1012
x
y
p1
p2
17
163
1000
1004
Ancora puntatori(5)
p1=p2;
1000
1004
1008
1012
x
y
p1
p2
17
163
1000
1004
Ancora puntatori(6)
Passaggio di parametri per riferimento Aritmetica dei puntatori malloc free
Strutture
struct emprec{char name[25];int age;int pay;};struct emprec employee;employee.age=32;
C++ extend C
Le classi, con funzioni virtuali ed ereditarietà multipla
Le eccezioni Le variabili di riferimento I namespace I template di classe I template di funzione La libreria di ingresso/uscita La libreria per gestire stringhe La libreria per gestire contenitori …
Introduzione al C++ e alla programmazione ad oggetti
Introduzione
Le due componenti principali dei programmi:– Algoritmi: l’insieme delle istruzioni che svolgono un
particolare compito– Dati: ciò su cui gli algoritmi agiscono per produrre una
soluzione unica
La relazione fra queste componenti definisce il paradigma di programmazione– Programmazione procedurale: problemi modellati
dagli algoritmi. Dati immagazzinati in aree comuni o passate agli algoritmi
– Programmazione ad oggetti: problemi modellati dalle relazioni fra tipi di dati astratti (ADT, Abstract Data Types), chiamati generalmente oggetti
Il rapporto Dato-Algoritmo
Linguaggio Bits Bitsmacchina
Programmazione Dati Algoritmi
Liv
ello
di a
stra
zion
e
Assemblers Symbolic Op-code Words
Compilatori Variables & Statements Types
Linguaggi Data Subroutines strutturati structures
Ada (Modula) Abstract Packages Data Types (Modules)
Object Oriented Objects Objects
Cos’è un oggetto?
Né più né meno di quello che potreste trovare scritto in un vocabolario…– Un oggetto è un’entità che si possa immaginare dotata
di determinate caratteristiche e funzionalità. Lo stato di un oggetto è rappresentato da dati che
ne descrivono le caratteristiche in un certo istante Le funzionalità di un oggetto sono le operazioni
che può svolgere quando glie lo si richiede (cioè quando riceve un messaggio)
Nella nostra vita quotidiana siamo molto più abituati a ragionare per oggetti che non in modo strutturato!
Un esempio...
SoldatoSoldatoSoldatoSoldato
FunzioneFunzione
Funzione
Codice
funzione
CodicefunzioneCodice
funzione
… cos’è un oggetto:
Un insieme di dati e funzioni:
Dato
Dato
Dato
Incapsulazione
Netta divisione fra interfaccia e implementazione
Da fuori si vede solo l’interfaccia che definisce i messaggi accettati dall’oggetto
I dettagli dell’implementazione (dati e codice delle funzioni) sono invisibili dall’esterno
Ogni oggetto ha in se tutto ciò che gli serve per rispondere alle chiamate (o deve sapere a chi chiedere…)
Il confinamento di informazioni e funzionalità in oggetti permette livelli maggiori di astrazione e semplifica la gestione di sistemi complessi.
Approccio OO
Sono le strutture di dati che svolgono le azioni, non le subroutines
Il lavoro è svolto dal server, non dal client “Cos’ è?” “Com’ è fatto?”
Data Oriented “Cosa può fare per me?”
Object Oriented
Perché programmare per oggetti?
Programmare per oggetti non velocizza l’esecuzione dei programmi...
Programmare per oggetti non ottimizza l’uso della memoria...
E allora perchè programmare per oggetti? Programmare per oggetti facilita la progettazione
e il mantenimento di sistemi software molto complessi!
Caratteristiche del software non mantenibile
Rigidità– non può essere cambiato con faciltà– non può essere stimato l’impatto di una modifica
Fragilità– una modifica singola causa una cascata di modifiche
successive– i bachi sorgono in aree concettualmente separate
dalle aree dove sono avvenute le modifiche
Non riusabilità– esistono molte interdipendenze, quindi non è
possibile estrarre parti che potrebbero essere comuni
Programmazione ad oggetti
La programmazione ad oggetti, attraverso l’incapsulazione, consente di:– ridurre la dipendenza del codice di alto livello dalla
rappresentazione dei dati – riutilizzare del codice di alto livello– sviluppare moduli indipendenti l’uno dall’altro– avere codice utente che dipende dalle interfacce ma
non dall’implementazione
C++ e Object Orientation
Il C++ può essere usato come linguaggio procedurale o per programmazione ad oggetti
Object Orientation implementata attraverso il concetto di classe
Prima di affrontare il problema della programmazione OO con C++ dobbiamo:– capire dove la programmazione procedurale fallisce– affrontare la sintassi del C++
Programmazione procedurale Esempio: cinematica relativistica COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4) REAL P1(4), P2(4), P3(4), P4(4)
COSTHETA12 = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... COSTHETA13 = (P1(1)*P3(1) + P1(2)*P3(2) + + P1(3)*P3(3))/... COSTHETA14 = (P1(1)*P4(1) + P1(2)*P4(2) + + P1(3)*P4(3))/...
COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4) REAL P1(4), P2(4), P3(4), P4(4)
COSTHETA12 = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... COSTHETA13 = (P1(1)*P3(1) + P1(2)*P3(2) + + P1(3)*P3(3))/... COSTHETA14 = (P1(1)*P4(1) + P1(2)*P4(2) + + P1(3)*P4(3))/...
FUNCTION COSTHETA(P1, P2) REAL P1(4), P2(4) COSTHETA = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... END
FUNCTION COSTHETA(P1, P2) REAL P1(4), P2(4) COSTHETA = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... END
COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4) REAL P1(4), P2(4), P3(4), P4(4)
COSTHETA12 = COSTHETA(P1, P2) COSTHETA13 = COSTHETA(P1, P3)
COSTHETA14 = COSTHETA(P1, P4)
COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4) REAL P1(4), P2(4), P3(4), P4(4)
COSTHETA12 = COSTHETA(P1, P2) COSTHETA13 = COSTHETA(P1, P3)
COSTHETA14 = COSTHETA(P1, P4)
Idea: perché non usare una
function?
Idea: perché non usare una
function?
COMMON /MYDATA/ P1(4), P2(4), P3(4), P4(4) COMMON /MYDATA/ P1(4), P2(4), P3(4), P4(4)
Evoluzione del codice
Se cambia il formato del common block? COMMON /MYDATA/ P(4), E(4), THETA(4), PHI(4) COMMON /MYDATA/ P(4), E(4), THETA(4), PHI(4)
Bisogna cambiare la funzione (gli argomenti sono diversi)
COMMON /MYDATA/ P(4), E(4), + THETA(4), PHI(4)
COSTHETA12 = COSTHETA1(THETA(1),THETA(2), + PHI(1), PHI(2)) COSTHETA13 = COSTHETA1(THETA(1),THETA(3), + PHI(1), PHI(3)) COSTHETA14 = COSTHETA1(THETA(1),THETA(4), + PHI(1), PHI(4))
COMMON /MYDATA/ P(4), E(4), + THETA(4), PHI(4)
COSTHETA12 = COSTHETA1(THETA(1),THETA(2), + PHI(1), PHI(2)) COSTHETA13 = COSTHETA1(THETA(1),THETA(3), + PHI(1), PHI(3)) COSTHETA14 = COSTHETA1(THETA(1),THETA(4), + PHI(1), PHI(4))
FUNCTION COSTHETA1(THETA1, THETA2, + PHI1, PHI2) COSTHETA1 = SIN(THETA1)*SIN(THETA2) * + COS(PHI1-PHI2) + COS(THETA1)*COS(THETA2) END
FUNCTION COSTHETA1(THETA1, THETA2, + PHI1, PHI2) COSTHETA1 = SIN(THETA1)*SIN(THETA2) * + COS(PHI1-PHI2) + COS(THETA1)*COS(THETA2) END
...e il codice!
COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4)
COSTHETA12 = COSTHETA(P1, P2) COSTHETA13 = COSTHETA(P1, P3) COSTHETA14 = COSTHETA(P1, P4)
COMMON /MYDATA/ P1(4), P2(4), + P3(4), P4(4)
COSTHETA12 = COSTHETA(P1, P2) COSTHETA13 = COSTHETA(P1, P3) COSTHETA14 = COSTHETA(P1, P4)
Il concetto di dipendenza
Nell’esempio precedente il codice di analisi (“alto livello”) dipende dai dettagli della struttura dati (“basso livello”).
FUNCTION COSTHETA(P1, P2) REAL P1(4), P2(4) COSTHETA = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... END
FUNCTION COSTHETA(P1, P2) REAL P1(4), P2(4) COSTHETA = (P1(1)*P2(1) + P1(2)*P2(2) + + P1(3)*P2(3))/... END COSTHETA dipende
dalla struttura dei dati P1 e P2
Il codice di analisi dipende dalla struttura del common block MYDATA
OO riduce le dipendenze!
Riduce la dipendenza del codice di alto livello dalla rappresentazione dei datiPermette il riutilizzo del codice di alto livello
Nasconde i dettagli di implementazioneSupporta tipi di dati astratti
(vedere seguito ...)
Sintassi: FORTRAN vs C/C++
Struttura del programma
PROGRAM TESTC esempio di programma
...
END
PROGRAM TESTC esempio di programma
...
END
int main() { // esempio di programma
...
return 0; // fine}
int main() { // esempio di programma
...
return 0; // fine}
INTEGER I INTEGER*4 J REAL X REAL*8 D
INTEGER I INTEGER*4 J REAL X REAL*8 D
int i;long j;float x;double d;
int i;long j;float x;double d;
In C/C++ non è necessario un particolare formato il codice
spazi...
Il C/C++ è case sensitive Istruzioni separate da “;”
Il main program
Ogni programma in C++, per essere eseguibile, deve contenere una funzione main() da cui l’esecuzione comincerà
main() deve avere un tipo (decidere quale è compito del programmatore). Regola generale è che main() ritorni un intero, a significare il return code dell’applicazione
int main(){
// il piu` semplice programma in C++return 0;
}
int main(){
// il piu` semplice programma in C++return 0;
}
I/O: lettura e scrittura
Non esiste nel C++ nativo. Si usa: iostream
– Gli operatori << e >> sono usati per definire la direzione del flusso
– cin, cout e cerr rappresentano lo standard input, output e error del programma
#include <iostream>
int main(){ return 0;}
int main(){ return 0;}
direttiva al preprocessore
end of line
#include <iostream>
cout << “Hello, world !” << endl;
Commenti
Esistono due tipi di commento in C++– inline:
– multiline (come in C):
– I due tipi possono essere usati indifferentemente, ma si raccomanda di usare l’inline (più semplice e meno ambiguo)
const int Ntries; // questo e` un commento inline// il resto della linea e’ trattato come un commento
const int Ntries; /* questo e` un commento multiline: tutto viene trattato come un commento fino a quando il commento stesso non viene chiuso con uno */
Tipi predefiniti in C++
Sono definiti una serie di tipi numerici che permettono di rappresentare numeri interi, reali e caratteri
– char (un solo byte) viene normalmente usato per rappresentare interi inferiori a 256
– stringhe e numeri complessi sono implementati come tipi derivati
int intero in singola precisionelong intero in doppia precisionefloat reale in singola precisionedouble reale in doppia precisionelong double reale in precisione estesaunsigned int intero senza segnounsigned double reale senza segno in doppia precisionechar carattere singolobool variabili logiche
Tipi predefiniti in C++ (2)
123 123 0x123 interi costanti,decimale, ottale, esadecimale
123l 123u interi, long, unsigned
‘A’ ‘1’ ‘\t’ caratteri, tab3.14f 3.1415 3.1415L float, double,
long double300e-2 .03e2 30e-1 double, notazione
esponenziale“Nome” stringa costantetrue false boolean
Esempi di costanti ‘\a’ alert‘\\’ backslash‘\b’ backspace‘\r’ carriage return‘\”’ double quote‘\f’ form feed‘\t’ tab‘\n’ newline‘\0’ carattere nullo‘\’’ single quote‘\v’ vertical tab‘\101’ 101 ottale, ‘A’‘\x041’ esadecimale, ‘A’
Costanti carattere
“” stringa nulla (‘\0’)“nome” ‘n’ ‘o’ ‘m’ ‘e’ ‘\0’“una \”stringa\”” stampa: una “stringa”“una stringa \ un \ alla fine della linea su piu` linee” per continuare la stringa
Stringhe costanti
Tipi predefiniti in C++ (3)
char[1]
int[1]
bool
short[1]
long[1]
float
double
long double
8
16
16
16
32
32
64
64
8
32
32
16
32
32
64
128
8
32
32
16
64
32
64
128
OS16 bit
OS32 bit
OS64 bit
[1] Può essere unsigned
Identificatori
Un identificatore è composto da uno o più caratteri Il primo carattere deve essere una lettera o un
underscore. Caratteri successivi possono essere lettere, numeri o underscore
Non c’ è un limite in lunghezza, anche se alcuni sistemi si limitano a considerare i primi 31 caratteri
Gli identificatori che iniziano con un doppio underscore o con un underscore e una lettera maiuscola sono riservati ad usi di sistema
C++ e` case sensitive!
const int Ntries; double _attempts;double 2A; // errore!
Keywords
Alcuni identificatori sono esplicitamente riservati al sistema (hanno un preciso significato in C++) e non possono essere usati
asm else operator throwauto enum private truebool explicit protected trybreak extern public typedefcase false register typeidcatch float reinterpret_cast typenamechar for return unionclass friend short unsignedconst goto signed usingconst_cast if sizeof virtualcontinue inline static voiddefault int static_cast volatiledelete long struct wchar_tdo mutable switch whiledouble namespace templatedynamic_cast new this
keyword
const
La keyword const viene utilizzata per dichiarare un oggetto costante
In C le costanti vengono normalmente dichiarate usando il preprocessore– in questo caso N e` una costante senza tipo ed
il preprocessore sostituisce N ovunque lo trovi nel programma, senza rispettare le regole di scope (da evitare)
const int N=100; N non puo` essere cambiatodouble w[N]; N usato come per dimensionare
un vettoreconst int vect[5]= le componenti di vect non
{10,20,30,40,50}; possono essere cambiate
Esempi di const
#define N 100
Dichiarazione
Le dichiarazioni associano un significato ad un identificatore
in C++ ogni cosa deve essere dichiarata per poter essere usata
Una dichiarazione è spesso anche una definizione. Per variabili semplici questo consiste nell’associare un valore alla variabile al momento della dichiarazione
const int i; // la variabile idouble max(double r1,double r2); // la funzione max
const double pi=3.1415926; // definizionedouble max(double r1, double r2) { // dichiarazione
return (r1>r2) ? r1: r2; // definizione di max}
typedef
L’istruzione typedef viene utilizzata per creare un alias per tipi esistenti
typedef NON può essere usato per implementare nuovi tipi, ma solo per definire un alias
typedef int INTEGER; // per i nostalgici del fortrantypedef int BOOLEAN; // usato prima che bool venisse
// implementatotypedef void (*ptr_f)(); // ptr_f e` un puntatore ad una
// procedura (subroutine)
typedef mela frutto; // compila soltanto se mela// e` gia` stata definita
Enumeratori
In C++ sono supportati tipi definiti dall’utente
enum Color{ red, green, blue};
Color screenColor = blue;Color windorColor = red;
int n = blue; // validoColor c = 1; // errore
enum Seme{ cuori, picche, quadri, fiori};
Scope
Le variabili possono essere dichiarate e definite quasi ovunque in un programma in C++
la visibilità (scope) di una variabile dipende da dove la variabile è stata dichiarata
int func(){
…const int n=50; // function scopefor (int i=0;i<100;i++) // i e` locale{
double r; // r e` locale...
}cout<<“n “<< n <<endl; // OKcout<<“i “<< i <<endl; // errore! Ma...cout<<“r “<< r <<endl; // errore!…
}
Scope (2)
Attenzione! La stessa variabile può essere ri-dichiarata (con visibilità diversa). Questo è da evitare (se possibile) per non rendere il programma oscuro e a rischio di errore!int i; // file (global) scopeint func(){
int i=50; // function scope, nasconde // la i a file scope
for (int i=0;i<100;i++) // block scope. Nasconde// la i a function scope
{int i; // questo e` un errore......
}cout<<“i “<< i <<“ “<< ::i <<endl;...
}Scope resolution operator
namespace
Funzioni e variabili definite a global scope sono visibili dappertutto in un programma in C++– Per evitare che funzioni diverse (definite in librerie
diverse) con lo stesso nome possano interferire (name clash), C++ implementa il concetto di namespace, che introduce un ulteriore, più alto livello di scope
namespace mynames{
int i; // la mia dichiarazione di ifloat max(float, float); // la mia dichiarazione di max
}
float mynames::max(float a, float b) // implementazione della{ // funzione max appartenente
return (a>b) ? a : b; // al namespace mynames}
namespace (2)
Per utilizzare variabili e funzioni racchiuse in un namespace si può:– o accedere all’intero namespace
– oppure accedere alla singola variabile o funzione
– oppure dichiarare la singola funzione
using namespace mynames;...float r = max (2.1f, 5.3f);
float r = mynames::max (2.1f, 5.3f);
using mynames::max;...float r = max (2.1f, 5.3f);
-i +w piu` e meno unaria*b a/b i%2 moltiplicazione,
divisione, moduloa+b a-b addizione e
sottrazione binariea=3; assegnazione
Espressioni Aritmetiche Commento
Operatori
k = ++j; j=j+1; k=j;k = j++; k=j; j=j+1;k = --j; j=j-1; k=j;k = j--; k=j; j=j-1;
Auto-incremento Espressione e decremento
~i; Complemento bit a biti&j; AND bit a biti|j OR bit a biti^j XOR bit a biti<<n shift a sinistra di n pos.i>>n shift a destra di n pos.
bit-wise significato
< minore di .LT.> maggiore di .GT.<= minore o uguale .LE.>= maggiore o uguale .GE.== uguale .EQ.!= diverso .NE.! Negazione unaria .NOT.&& and logico .AND.|| or logico .OR.
Operatori relazionali Fortran
Espressioni di assegnazione
Le espressioni di assegnazione sono valutate da destra a sinistra
Le assegnazioni multiple sono permesse
alcuni operatori di assegnazione combinano assegnazione ed altri operatori
Assegnazioni possono essere fatte all’interno di espressioni aritmetiche
a = j++;j viene incrementato ed il risultato assegnato ad a
a = b = c = d = 100;
a *= b; // equivale ad a = a*b;a -= b; // equivale ad a = a-b;
a = b + ( c = 3 ); // equivale a c=3; a=b+c;
Statements
vuoto ;espressione j=j+k;composto { . . . . } usato in funzioni, if..
Costituisce un bloccogoto goto label; da non usarsiif if (p==0)
cerr<<“error”; un solo branchif-else if (x==y)
cout<<“the same”;else cout<<“different”; due branch
for for (j=0;j<n;j++) le dichiarazioni sonoa[j]=0; permesse
while while (i != j) 0 o piu` iterazioni i++;
do-while do y=y-1; 1 o piu` iterazioniwhile (y>0);
break break; esce dal bloccocontinue continue; prossima iterazione
Statement C++ commenti
Statements (2)
switch switch (s) {case 1: si deve usare break per
++i; evitare di cadere nei case 2: casi successivi e
--i; aggiungere un caso didefault: default alla fine della
++j; lista};
dichiarazione int i=7; in un blocco, file onamespace
try try {. . . .} usato per trattare leeccezioni
label error: cerr<<“Error!”; usato con goto
return return x*x*x; valore di ritorno di una funzione
Statement C++ commenti
Statement composti
Uno statement composto in è costituito da una serie di statement contenuti fra parentesi graffe
Usato normalmente per raggruppare istruzioni in un blocco (if, for, while, do-while, etc.)
Il corpo di una funzione è sempre uno statement composto
La dichiarazione di una variabile può avvenire ovunque all’interno di un blocco, in questo caso lo scope della variabile sarà il blocco stesso
Ovunque si possa usare uno statement singolo si può definire un blocco
if
Attenzione all’uso di = e ==
Nel dubbio, usare sempre un blocco…
Attenzione agli else!
if (i=1) // questo e` sempre vero!!!{. . . .}
if (i != 0) // possibile divisione per 0a++; // mancano delle {}?a/=i;
if (i == 0) // possibile divisione per 0if (a<0)
{cerr<<“a e` negativo!”;
}else b=a/i;
while e do-while
La forma generale di un while è :
Lo statement verrà eseguito fino a quando la condizione verrà verificata (true). A seconda del volore della condizione, lo statement verrà eseguito zero o più volte
la sintassi di un do-while è invece:
Lo statement verrà quindi eseguito almeno una volta
while (condizione)statement;
dostatement;
while (condizione);
break e continue
break e continue sono utilizzati nei loop per saltare alla fine del loop o fuori dal loop stesso
break e continue possono solamente essere utilizzati nel corpo di un for, while o do-while. break e` anche usato negli switch
int i,n=0;int a[100];cin>>i; // leggo il valore di iwhile (1) // loop infinito{
if (i<0) break;if (n>=100) continue;a[n]=i;n++;// continue salta qui
}// break salta qui
switch
Lo switch è uno statement condizionale che generalizza lo if-else
lo statement è generalmente composito e consiste di diversi case e, opzionalmente, di un default
switch (condizione)(statement);
switch (n) {case 0:
cout<<“ n e` nullo”<<endl; break;case 1: case 3: case 5: case 7: case 9:
cout<<“ n e` dispari”<<endl; break;case 2: case 4: case 6: case 8: case 10:
cout<<“ n e` pari”<<endl; break;default:
cout<<“ n non e` compreso tra 0 e 10”<<endl;}
switch (2)
Non si puo` dichiarare una variabile in uno dei case
… ma si puo` creare una variabile locale definendo uno statement composto...
switch (k) {case 0:
int j=0; // Illegale! Errore!. . .
case 1: . . .
}
switch (k) {case 0:
{int j=0; // OK, questo compila. . .}
case 1: . . .
}
L’operatore ?
L’operatore ? e` l’unico esempio di operatore ternario in C++
– Equivale a:
– Esempio:
expr1 ? expr2 : expr3;
double max(double a, double b){
double max = (a>b) ? a : b;return max;
}
if(expr1) expr2;else expr3;
Sintassi: FORTRAN vs C/C++
Controllo di flusso del programma
DO I = 1, 10 . . . ENDDO
IF (I.EQ.10 .AND. J.GT.4 .OR. X) THEN . . . ENDIF
DO WHILE(X .NE. 5) . . . ENDDO
DO I = 1, 10 . . . ENDDO
IF (I.EQ.10 .AND. J.GT.4 .OR. X) THEN . . . ENDIF
DO WHILE(X .NE. 5) . . . ENDDO
for (i = 1; i <= 10; i++) { . . .}
if (i == 10 && j > 4 || x) { . . .}
while( x != 5 ){ . . .}
for (i = 1; i <= 10; i++) { . . .}
if (i == 10 && j > 4 || x) { . . .}
while( x != 5 ){ . . .}
int main(){
return 0;}
int main(){
return 0;}
Funzioni matematiche
In C++ non esistono funzioni predefinite
cmath.h definisce sin, cos, ...
{ double r, theta, phi;
#include <iostream>
cin >> r >> theta >> phi ;
#include <cmath>
double x = r * sin( theta ) * sin( phi ); double y = r * sin( theta ) * cos( phi ); double z = r * cos( theta );
cout << x << “, “ << y << “, “ << z << endl;
Potenze: pow(b,exp) (non si può usare ** )
Array
Sono supportati gli array di dimensione fissaint main(){ int x[10];
for ( int i = 0; i < 10, i++ ) x[i] = 0;
double m[5][5];
for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 5; j++ ) m[i][j] = i * j;
return 0;}
int main(){ int x[10];
for ( int i = 0; i < 10, i++ ) x[i] = 0;
double m[5][5];
for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 5; j++ ) m[i][j] = i * j;
return 0;}
L’indice va da 0 a n-1. Usare un indice maggiore di n-1 può causare un crash.
int x[] = { 1, 2, 3, 4 };
char[] t = { ‘C’, ‘i’, ‘a’, ‘o’, ‘\0’ };
char[] s = “Ciao”;
int m[2][3] = { {11, 12, 13}, {21, 22, 23} };
int x[] = { 1, 2, 3, 4 };
char[] t = { ‘C’, ‘i’, ‘a’, ‘o’, ‘\0’ };
char[] s = “Ciao”;
int m[2][3] = { {11, 12, 13}, {21, 22, 23} };
Inizializzazione:
Esempio con gli arrays
Moltiplicazione fra matrici:
int main() {
const int DIM=3;
float m[DIM][DIM], m1[DIM][DIM], m2[DIM][DIM]; // Assumiamo che m1 ed m2 vengano riempiti qui...
// Moltiplicazione:
for (int i=0; i<DIM; i++) {
for (int j=0; j<DIM; j++) {
float sum=0;
for (int k=0; k<DIM; k++)
sum += m1[i][k] * m2[k][j];
m[i][j] = sum;
}
}
return 0;}
int main() {
const int DIM=3;
float m[DIM][DIM], m1[DIM][DIM], m2[DIM][DIM]; // Assumiamo che m1 ed m2 vengano riempiti qui...
// Moltiplicazione:
for (int i=0; i<DIM; i++) {
for (int j=0; j<DIM; j++) {
float sum=0;
for (int k=0; k<DIM; k++)
sum += m1[i][k] * m2[k][j];
m[i][j] = sum;
}
}
return 0;}
12240x7b03a928
Puntatori
Riferimento ad una locazione di memoria
j
12
ptr
int main(){ int j = 12;
return 0;}
int main(){ int j = 12;
return 0;}
int *ptr = &j;
#include <iostream>
cout << *ptr << endl; j = 24; cout << *ptr << endl; cout << ptr << endl;
indirizzo di memoria
24
Puntatori
Puntatore nullo
#include <iostream>
int main(){ int j = 12; int *ptr = 0;
cout << *ptr << endl; // crash ! return 0;}
#include <iostream>
int main(){ int j = 12; int *ptr = 0;
cout << *ptr << endl; // crash ! return 0;}
Segmentation violation (core dumped)
j
12
ptr
Puntatori e array
In C gli array sono trattati come puntatori
int main(){ float x[5]; int j; for (j = 0; j < 5; j++) x[j] = 0;
float *ptr = x; *ptr = 1.5; // x[0] = 1.5 *(ptr+1) = 2.5; // x[1] = 2.5 *(ptr+3) = 3.5; // x[3] = 3.5}
int main(){ float x[5]; int j; for (j = 0; j < 5; j++) x[j] = 0;
float *ptr = x; *ptr = 1.5; // x[0] = 1.5 *(ptr+1) = 2.5; // x[1] = 2.5 *(ptr+3) = 3.5; // x[3] = 3.5}
x
X[0]
1.5
X[1] X[2] X[3] X[4]
2.5 0.0 3.5 0.0
X+1 X+3
Puntatori: allocazione dinamica
Riferimento ad una locazione di memoria
#include <iostream>
int main(){ int *ptr = new int;
*ptr = 12; cout << *ptr << endl;
delete ptr; return 0;}
#include <iostream>
int main(){ int *ptr = new int;
*ptr = 12; cout << *ptr << endl;
delete ptr; return 0;}
12
ptr
Attenzione:– Non usare delete fa accumulare locazioni di memoria
inutilizzate (memory leak)– Utilizzare puntatori prima del new o dopo il delete
causa il crash del programma
Puntatori: allocazione dinamica
Riferimento a più locazioni di memoria
#include <iostream>
int main(){ int *ptr = new int[3];
ptr[0] = 10; ptr[1] = 11; ptr[2] = 12
delete [] ptr; return 0;}
#include <iostream>
int main(){ int *ptr = new int[3];
ptr[0] = 10; ptr[1] = 11; ptr[2] = 12
delete [] ptr; return 0;}
10
ptr
11 12
new e delete
Gli operatori new and delete vengono utilizzati per allocazione/deallocazione di memoria dinamica
– la memoria dinamica (heap), è un’area di memoria libera provvista dal sistema per quegli oggetti la cui durata di vita è sotto il controllo del programmatore
new riserva la quantità necessaria di memoria richiesta e ritorna l’indirizzo di quest’area
int *i=new int; alloca un intero, returna il puntatorechar *c=new char[100]; alloca un array (stringa) di 100
caratteriint *i=new int(99); alloca un intero e lo inizializza a 99char *c=new char(‘c’); alloca un carattere inizializzato a cint *j=new int[n][4]; alloca un array di puntatori ad intero
operatore new commenti
new e delete (2)
L’operatore delete è usato per restituire una certa area di memoria (allocata con new) allo heap
Ogni oggetto allocato con new deve essere distrutto con delete se non viene piu` utilizzato, altrimenti l’area di memoria che esso occupata non potra` piu` essere ri-allocata (memory leak)
L’argomento di delete è tipicamente un puntatore inizializzato preventivamente con new
delete ptr; distrugge un puntatore ad un oggettodelete p[i]; distrugge l’oggetto p[i]delete [] p; distrugge ogni oggetto di tipo p
operatore delete commenti
new e delete (3)
Attenzione– la dimensione dello heap non e` infinita– l’allocazione con new può fallire, nel qual caso new restituisce un puntatore nullo o suscita un’eccezione. Nel caso di allocazione di memoria importante bisogna verificare che l’operazione abbia avuto successo prima di usare il puntatore
– ogni oggetto creato con new deve essere distrutto con delete, ogni oggetto creato con new [] deve essere distrutto con delete [] , queste forme NON sono intercambiabili
Regole di conversione e cast
In C++ esistono conversioni esplicite ed implicite. – Le conversioni implicite (e.g. intfloat) nelle
espressioni aritmetiche, nel passare i parametri ad una funzione o nel ritornare un valore da una funzione rendono il meccanismo di conversione molto conveniente ma anche potenzialmente pericoloso (errori a run time)
•char, short e bool vengono promossi ad int•Tipi interi che non possono essere rappresentati con un int vengono promossi a unsigned•In una espressione di tipo misto, gli operandi di ordine inferiore vengono promossi all’ordine superiore secondo la gerarchia:
int<unsigned<long<unsigned long<float<double<long double•bool e` un tipo intero, con true che viene promosso a 1 e false a 0
Conversioni implicite
Regole di conversione e cast (2)
Ogni genere di puntatore può essere convertito in un puntatore generico a void
Al contrario di quanto avviene in C, un puntatore generico non è compatibile con un puntatore di tipo arbitrario ma richiede un cast esplicito
Ogni puntatore puo` essere inizializzato a 0 senza bisogno di un cast esplicito.
In C++ usare 0 e non NULL per i puntatori!
char *ch;void *generic_p;. . .generic_p=ch; // OK, char* va in void*ch=generic_p; // OK in C, illegale in C++ch=(char *)generic_p; // OK, C e C++ arcaico
Casting in ANSI C++
Data la complessità delle operazioni di casting in C++ nuovi operatori di casting sono stati aggiunti a quelli già esistenti in C
Esiste anche un dynamic_cast, utilizzato per riconoscere il tipo di un oggetto a run-time (RTTI)
x=(float) i; cast in C++ - notazione C
x=float(i); cast in C++, notazione funzionale
x=static_cast<float>(i); ANSI C++ - raccomandato
i=reinterpret_cast<int>(&x) ANSI C++, non portabile e system dependent
func(const_cast<int>(c_var)) dove C_var e` una variabile dichiarata const. Usato per eliminare la “const-ness” per chiamare func
Cast commenti
Funzioni
In C++ le funzioni sono caratterizzate da un nome, dal tipo della variabile ritornata e da una lista di parametri (opzionali)
La lista dei parametri (anche se vuota) deve essere esplicitata
Il valore ritornato deve essere compatibile, a meno di conversione esplicita, con il tipo della funzione
Valore di ritorno
double max( double a, double b) {
return (a>b) ? a : b;}
Tipo ritornato Parametri
Corpo dellafunzione
Funzioni (2)
funzione double cube(double x) parametri passati { return x*x*x; } “by value”
procedura void pr_square(int i) subroutine, non si { cout<<i*I<<endl; } usa return
senza argomenti void hello () puo` anche essere { cout<<“Hello”<<endl; } void hello(void)
argomenti passati void swap(int& i,int& j) i e j hanno i loro per riferimento { int t=i; i=j; j=t; } valori scambiati
variabile int scanf(const char, …) chiamata con un qualsiasi numero di argomenti
inline inline double cube(int x) codice inline
argomenti di int power(int i, int n=2) il 2do argomento default puo` essere
tralasciato
Tipo di dichiarazione C++ commenti
Prototipi delle funzioni
Prima di essere usata, una funzione deve essere dichiarata (nel file che la usa)
I prototipi rendono le funzioni in C++ “type safe”, nel senso che i valori reali degli argomenti vengono all’occorrenza convertiti nei tipi formali specificati dal prototipo
#include <iostream>double max(double, double);int main(){
double m = max(1, 3);cout<<“Il massimo e` “<<m<<endl;return 0;
}
#include <iostream>double max(double, double);int main(){
double m = max(1, 3);cout<<“Il massimo e` “<<m<<endl;return 0;
}
main.ccmain.cc
double max (double a, double b){
return (a>b) ? a : b;}
double max (double a, double b){
return (a>b) ? a : b;}
max.cc max.cc
Prototipo di max(normalmente in max.h)
Call-by-Reference
L’uso dei riferimenti permette ad una funzione di modificare il valore dei suoi argomenti
– Per ragioni di efficenza, oggetti di grandi dimensioni (in termini di memoria) vengono normalmente passati “by reference”.
– Per evitare che possano essere modificati dalla funzione, il riferimento viene definito const
bool greater(int& i, int& j) { // se i>j scambia i e jif (i>j) {
int temp=i;i=j;j=temp;return true;
}else
return false;}
Argomenti passati “by reference”possono essere modificati dallafunzione stessa
Funzioni inline
La keyword inline suggerisce al compilatore che ogni chiamata alla funzione deve essere convertita in codice eseguibile (la definizione della funzione viene sostituita alla chiamata dovunque nell codice)
Le funzioni inline vengono usate per ragioni di efficienza e (per non sovraccaricare il compilatore) devono essere semplici
Il compilatore può decidere autonomamente (per esempio se la funzione è troppo lunga) di ignorare la direttiva inline
Argomenti di default
Ad ogni parametro di una funzione può essere assegnato un valore di default. Questo permette di chiamare la funzione tralasciando quei parametri il cui valore di default risulta appropriato
Solo ai parametri più a destra nella calling sequence può essere dato un default.
int pow(int , int);
int main(){
int r=3;int a1=pow(3,3); // a1=27int a2=pow(3); // a2=9return 0;
}
int pow(int , int);
int main(){
int r=3;int a1=pow(3,3); // a1=27int a2=pow(3); // a2=9return 0;
}
main.ccmain.cc
int pow (int a, int k=2){
if (k==2) return a*a;else return a*pow(a, k-1);
}
int pow (int a, int k=2){
if (k==2) return a*a;else return a*pow(a, k-1);
}
pow.ccpow.cc
Argomento di default
Overloading
Funzioni diverse possono avere lo stesso nome La funzione che viene chiamata è scelta dal
compilatore in base al tipo di ritorno ed al numero e tipo degli argomenti
double average_array(const int a[], int size){
int sum=0;for (int i=0;i<size;i++) sum+=a[i];return double(sum)/size;
} double average_array(const double a[], int size){
double sum=0;for (int i=0;i<size;i++) sum+=a[i];return sum/size;
}
double average_array(const int a[], int size){
int sum=0;for (int i=0;i<size;i++) sum+=a[i];return double(sum)/size;
} double average_array(const double a[], int size){
double sum=0;for (int i=0;i<size;i++) sum+=a[i];return sum/size;
}
average_array.ccaverage_array.cc
Overloading (2)
La lista dei tipi degli argomenti di una funzione è chiamata signature
Il tipo ritornato dalla funzione non fa parte della signature, mentre il numero e l’ordine degli argomenti è cruciale
void print(int i=0) {. . .} // (1)void print(int i, double x) {. . .} // (2)void print(double y, int i) {. . .} // (3). . .print(‘A’); // ‘A’ e` convertito a int, chiama (1)print(str[]); // errore! Non e` possibile una conversioneprint(15,9); // errore! Ambiguita` fra (2) e (3)print(15,9.); // OK, chiama (2)print(); // OK, chiama (1) con il default
L’algoritmo di selezione
L’utente può sempre utilizzare una conversione forzata (type cast) per ottenere una corrispondenza
Il compilatore segnala tutti i casi in cui esiste ambiguità
Ricerca della corrispondenza esatta
Promozioni standard degli argomenti
Conversioni standard dei tipi
Conversioni definite dall’utente
Corrispondenza con l’ellipsi (…)
int long
int float
traccia int
I te
ntat
ivi d
el c
ompi
lato
re
Funzioni esterne
Si possono chiamare funzioni FORTRAN da C++:
SUBROUTINE HBOOK1(ID, TITLE, NBIN, MIN, MAX, OPT)
SUBROUTINE HFILL(ID,X, Y, WEIGHT)
extern “C” void hbook1_(int&, char*, int&, float&, float&, float&, int);
extern “C” void hfill_(int&, float&, float&, float&);
...
hbook1_(100, title, ……) // BUS ERROR!!! (il FORTRAN passa
// sempre “by-reference”
int id=100;
hbook1_(id, title, ……) // OK!
Parametri del programma
Dotando main() di una lista di argomenti, è possibile avere accesso ai parametri passati dalla command line:
argc è il numero di parametri passati dalla command line (sempre almeno 1, il nome del programma) mentre il vettore di stringhe argv contiene ogni singolo parametro
#include <iostream.h>int main(int argc, char *argv[]){
cout<<“ argc e`: “<<argc<<endl;cout<<“ il nome dell’eseguibile e` “<<*argv<<endl;for (int i=1; i<argc; i++)
cout<<“Argomento #”<<i<<“ = “<<*(argv+i)<<endl;
return 0;}
Parametri del programma (2)
Lanciato con il comandoprompt> mytest questo e un test
il programma produrra` il seguente output: argc e` : 5 il nome dell’eseguibile e`/user/andrea/myprogramArgomento #1 = questo Argomento #2 = eArgomento #3 = unArgomento #4 = test
Organizzazione dei files
Normalmente, le dichiarazioni delle interfacce e le specifiche sono separate dall’implementazione– header files (.h o .hh)
inclusi nei file sorgente utilizzando direttive del precompilatore
non contengono codice eseguibile (con l’eccezione delle definizioni delle funzioni inline)
non devono essere inclusi piu` di una volta, per evitare problemi con il linker
#include <iostream.h>
#ifndef MyHeader_H#define MyHeader_H// dichiarazioni…..#endif
Organizzazione dei files (2)
– Files sorgente (.C,.cxx,.cpp,.cc) contengono l’implementazione di funzioni e metodi codice eseguibile includono gli header files utilizzando le direttive del
preprocessore vengono compilati
– Funzioni inline (.icc) La definizione di una funzione inline deve essere
visibile là dove viene usata. Normalmente implementate negli header files o in
files separati (con estensione .icc) che devono essere inclusi nel files sorgente che ne facciano uso
C++ e Object Orientation
Definizione di nuovi tipi (oltre a int, float, double) come:
numeri complessi,vettori,matrici, . . .
ma anche:traiettorie,superfici,elementi di apparati sperimentali,...
Gli oggetti permettono di modellare una problema che rappresenti la realtà
…C++ e Object Orientation
Object Orientation implementata in C++ attraverso il concetto di classe:
I dati privati (o attributi) di una classe definiscono lo stato dell’oggetto
Le funzioni (o metodi) di una classe implementano la risposta ai messaggi
Una classe C++
MessaggioMessaggio
Messaggio
Metodo
Metodo
MetodoAttributo
Attributo
Attributo
Classe Vector2D
Un esempio: un vettore bidimensionale
class Vector2D{public:
Vector2D(double x, double y);double x();double y();double r();double phi();
private:double x_;double y_
};
class Vector2D{public:
Vector2D(double x, double y);double x();double y();double r();double phi();
private:double x_;double y_
};
Vector2D.hVector2D.hcostruttore
funzioni o metodi
dati o attributi
Punto e virgola!
#include “Vector2D.h”Vector2D::Vector2D(double x, double y): x_(x),
y_(y) { }double Vector2D::x() { return x_; }
double Vector2D::r() { return sqrt( x_*x_ + y_*y_); }
...
#include “Vector2D.h”Vector2D::Vector2D(double x, double y): x_(x),
y_(y) { }double Vector2D::x() { return x_; }
double Vector2D::r() { return sqrt( x_*x_ + y_*y_); }
...
Vector2D.ccVector2D.cc
Interfaccia e implementazione
#include “Vector.h”
Vector2D::Vector2D(double x, double y) : x_(x), y_(y){}
double Vector2D::x(){ return x_; }
double Vector2D::r(){ return sqrt(x_*x_ + y_*y_); }
Vector2D.ccVector2D.cc
class Vector2D{public: Vector2D(double x, double y); double x(); double y(); double r(); double phi();private: double x_; double y_;};
Vector2D.hVector2D.h
Gli attributi privati non sono accessibili al di fuori della classe
I metodi pubblici sono gli unici visibili
Costruttori e distruttori
Un costruttore è un metodo il cui nome è quello della classe a cui appartiene
Lo scopo di un costruttore è quello di costruire oggetti del tipo della classe. Questo implica l’inizializzazione degli attributi e, frequentemente, allocazione di memoria dallo heap
Un costruttore la cui lista di argomenti è vuota o composta di argomenti di default viene normalmente chiamato costruttore di default Vector2D::Vector2D() {. . . .} // costruttore di default
#include “Vector2D.h”. . .
Vector2D v; // oggetto costruito con il // costruttore di default
Costruttori e distruttori (2)
Un costruttore del tipo che ha come argomento un riferimento ad un oggetto della stessa classe viene chiamato copy constructor
Il copy constructor viene normalmente utilizzato:– quando un oggetto è inizializzato per assegnazione
– quando un oggetto è passato come argomento ad una funzione
– quando un oggetto è ritornato da una funzione
Se non viene fornito esplicitamente dall’utente, il compilatore ne genererà uno automaticamente
Vector2D::Vector2D(const Vector2D& v) {. . . .}
Vector2D v(v1); // dove v1 e` di tipo Vector2D
Costruttori e distruttori (3)
Gli attributi di una classe possono essere inizializzati nel costruttore per mezzo di una lista di inizializzatori, che precede il corpo della funzione
Quando uno degli attributi è esso stesso una classe, il costruttore appropriato viene scelto sulla base dei parametri forniti nell’inizializzazione
E` obbligatorio inizializzare gli attributi (non statici) che siano o riferimenti o const
Vector2D::Vector2D(double x, double y) : x_(x), y_(y){. . . }
Costruttori e distruttori (4)
Il distruttore è un metodo il cui nome è quello della classe a cui appartiene preceduto da una tilde (~)
Il distruttore viene chiamato automaticamente quando un oggetto sta per essere distrutto (sia perchè delete è stato invocato sia perchè l’oggetto è finito fuori scope
Il compito del distruttore è di assicurarsi che l’oggetto per cui è invocato verrà distrutto senza conseguenze. In particolare, se memoria è stata allocata nel costruttore, il distruttore dovrà assicurarsi di restituirla allo heap
Vector2D::~Vector2D() {} // vuoto, in questo caso
Costruttori e distruttori (5)
I costruttori con un solo parametro sono automaticamente trattati come operatori di conversione
Per evitare la conversione si puo` usare explicit
Vector2D::Vector2D(int i) {. . .}// costruisce un vettore a partire da un intero, ma puo` // essere usato per convertire un intero in vettore
v=Vector2D(i);
explicit Vector2D(int); // solo costruttore
Classe Vector2D
#include <iostream.h>#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ v = (“ << v.x() << “,” << v.y() << “)” << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl; return 0;}
#include <iostream.h>#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ v = (“ << v.x() << “,” << v.y() << “)” << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl; return 0;}
main.ccmain.cc
Come usare Vector2D:
v = (1, 1)r = 1.4141 phi = 0.7854v = (1, 1)r = 1.4141 phi = 0.7854
Output:Output:
invoca il constructor
Classe Vector2D
#include <iostream.h>#include “Vector2D.h”
int main(){ Vector2D *v = new Vector2D(1, 1); cout << “ v = (“ << v->x() << “,” << v->y() << “)” << endl; cout << “ r = “ << v->r(); cout << “ phi = “ << v->phi() << endl; delete v; return 0;}
#include <iostream.h>#include “Vector2D.h”
int main(){ Vector2D *v = new Vector2D(1, 1); cout << “ v = (“ << v->x() << “,” << v->y() << “)” << endl; cout << “ r = “ << v->r(); cout << “ phi = “ << v->phi() << endl; delete v; return 0;}
main.ccmain.cc
… oppure attraverso un puntatore...
v = (1, 1)r = 1.4141 phi = 0.7854v = (1, 1)r = 1.4141 phi = 0.7854
Output:Output:
Allocazione sullo heap
Attenzione!
Interfaccia e implementazione
La struttura interna dei dati (x_, y_) che rappresentano l’oggetto della classe Vector2D sono nascosti (private) agli utilizzatori della classe.
Gli utilizzatori non dipendono dalla struttura interna dei dati (come lo erano gli utilizzatori dei common blocks Fortran)
Se la struttura interna cambia (es.: r_, phi_), il codice che usa Vector2D non deve essere modificato.
Protezione dell’accesso ai dati:
I metodi di una classe hanno libero accesso ai dati privati e protetti di quella classe
Classe Vector2D
#include <iostream>#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ V = (“ << v.x_ << “,” // << v.y_ << “,” << endl; // non compila ! cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
#include <iostream>#include “Vector2D.h”
int main(){ Vector2D v(1, 1); cout << “ V = (“ << v.x_ << “,” // << v.y_ << “,” << endl; // non compila ! cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
main.ccmain.cc
Selettore: metodo che non modifica lo stato (attributi) della classe. E’ dichiarato const
Modificatore: metodo che può modificare lo stato della classe
Selettori e modificatori
#include “Vector2D.h”
void Vector2D::scale(double s){ x_ *= s; y_ *= s;}
Vector2D.ccVector2D.cc
class Vector2D{public: Vector2D(double x, double y); double x() const; double y() const; double r() const; double phi() const; void scale(double s);private: double x_, y_;};
Vector2D.hVector2D.h
modificatore
#include “Vector2D.h”int main(){ const Vector2D v(1, 0); double r = v.r() // OK v.scale( 1.1 ); // errore!}
#include “Vector2D.h”int main(){ const Vector2D v(1, 0); double r = v.r() // OK v.scale( 1.1 ); // errore!}
main.ccmain.ccSelettori (const)
friend
La keyword friend puo` essere usata perche` una funzione (o una classe) abbia libero accesso ai dati privati di un’altra classe
class A {. . .
friend int aFunc();friend void C::f(int);
}; class B {…
friend class C;};class C {. . .};
friend (2)
friend (nonostante il nome) e` nemico dell’incapsulamento e quindi dell’Object Orientation
Un uso eccessivo di friend è quasi sempre sintomo di un cattivo disegno
Esistono anche situazioni in cui un friend può essere accettabile– Overloading di operatori binari– Considerazioni di efficienza– Relazione speciale fra due classi
“A programmer must confer with an architect before making friend declarations”
static
Attributi dichiarati static in una classe sono condivisi da tutti gli oggetti di quella classe
Metodi dichiarati static non possono accedere ad attributo non statici della classe
Attiributi statici possono essere usati e modificati soltanto da metodi statici
Nonostante l’utilizzo di static sembri imporre condizioni troppo restrittive, esso risulta utile nell’implementazione di:– contatori– singleton (vedi oltre)
Un contatore
Class MyClass {private:
static int counter;static void increment_counter() { counter++; }static void decrement_counter() { counter--; }
public:MyClass() { increment_counter(); }~MyClass() { decrement_counter(); }static int HowMany() { return counter; }
};#include <iostream.h>#include “MyClass.h”
int MyClass::counter=0;
int main() {MyClass a,b,c;MyClass *p=new MyClass;cout<<“ How many? “<< MyClass::HowMany() <<endl;delete p;cout<<“ and now? “<< a.HowMany() <<endl;return 0;
}
Un membro statico deve essereinizializzato una e una sola volta
nel codice eseguibile
Un metodo statico puo` essere invocato cosi`...
… o cosi`...
Un singleton
Un singleton è una classe di cui, ad ogni momento nel corso del programma, non può esistere più di una copia (istanza)
class aSingleton {private:
static aSingleton *ptr;aSingleton () {}
public:static aSingleton *GetPointer(){
if (ptr==0) ptr=new aSingleton;
return ptr; }
};
#include “aSingleton.h”
aSingleton *aSingleton::ptr=0;
int main() {aSingleton *mySing=
aSingleton::GetPointer();. . . Return 0;
}
Pattern utile per l’implementazione di classi “manager” di cui deve esistere una sola istanza
Attenzione a non farlodiventare l’equivalente di un common block!
Operatori
E’ possibile ridefinire +, -, *, [], ++, ==, . . .
class Vector2D{public: Vector2D(double x, double y); double x() const; double y() const; double r() const; double phi() const;private: double x_; double y_;};
Vector2D operator+(const Vector2D& v1, const Vector2D& v2);
Vector2D operator-(const Vector2D& v1, const Vector2D& v2);
class Vector2D{public: Vector2D(double x, double y); double x() const; double y() const; double r() const; double phi() const;private: double x_; double y_;};
Vector2D operator+(const Vector2D& v1, const Vector2D& v2);
Vector2D operator-(const Vector2D& v1, const Vector2D& v2);
Vector2D.hVector2D.h
Vector2D operator+(const Vector2D& v1, const Vector2D& v2)
{ return Vector2D(v1.x() + v2.x(), v1.y() + v2.y());}
Vector2D operator-(const Vector2D& v1, const Vector2D& v2)
{ return Vector2D(v1.x() - v2.x(), v1.y() - v2.y());}
Vector2D operator+(const Vector2D& v1, const Vector2D& v2)
{ return Vector2D(v1.x() + v2.x(), v1.y() + v2.y());}
Vector2D operator-(const Vector2D& v1, const Vector2D& v2)
{ return Vector2D(v1.x() - v2.x(), v1.y() - v2.y());}
Vector2D.ccVector2D.cc
Operatori (2)
Esempio:
#include <iostream>#include “Vector2D.h”
int main(){ Vector2D v1(1, 0), v2(0, 1); Vector2D v; v = v1 + v2; cout << “ v = “ << v << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
#include <iostream>#include “Vector2D.h”
int main(){ Vector2D v1(1, 0), v2(0, 1); Vector2D v; v = v1 + v2; cout << “ v = “ << v << endl; cout << “ r = “ << v.r(); cout << “ phi = “ << v.phi() << endl;}
main.ccmain.cc
v = (1, 1)r = 1.4141 theta = 0.7854
Output:ridefinizione di <<
v.operator=( operator+(v1, v2) );
Sintassi alternativa (!#@!?) :
Operatori (3)
Esempio:
#include <iostream>#include <cmath>#include “Vector3D.h”#include “Matrix.h” // matrice 3x3
int main(){ Vector3D v1(1, 1, 0);
double phi = M_PI/3; double c = cos(phi), s = sin(phi);
Matrix m(1, 0, 0, 0, c, s, 0, -s, c); Vector3D u = m * v;}
#include <iostream>#include <cmath>#include “Vector3D.h”#include “Matrix.h” // matrice 3x3
int main(){ Vector3D v1(1, 1, 0);
double phi = M_PI/3; double c = cos(phi), s = sin(phi);
Matrix m(1, 0, 0, 0, c, s, 0, -s, c); Vector3D u = m * v;}
main.ccmain.cc
greco
this
In una classe è automaticamente definito un attributo particolare: this– this è un puntatore all’oggetto di cui fa parte– E’ particolarmente utile quando si definisce un
operatore di assegnazione (=):
class Vector2D {public: Vector2D& operator=(const Vector2D& ); // ...private: double x_, y_;};
class Vector2D {public: Vector2D& operator=(const Vector2D& ); // ...private: double x_, y_;};
Vector2D.hVector2D.hVector2D& operator=(const Vector2D& v){ x_=v.x(); y_=v.y(); return *this;}
Vector2D& operator=(const Vector2D& v){ x_=v.x(); y_=v.y(); return *this;}
Vector2D.ccVector2D.cc
#include “Vector2D.h”int main() { Vector2D null(0, 0); Vector2D a, b; a=b=null;}
#include “Vector2D.h”int main() { Vector2D null(0, 0); Vector2D a, b; a=b=null;}
main.ccmain.cc
L’operatore = ritorna una referenza a se stesso. Permette assegnazionimultiple
Overloading di operatori
possono esistere funzioni con lo stesso nome ma con argomenti diversi
Non bisogna pero` esagerare! Ogni operatore deve avere un significato ben preciso, per ragioni di chiarezza.
class Vector2D {public: // ...private: double x_, y_;};
Vector2D operator*(const Vector2D &, double);
double operator*(const Vector2D&, const Vector2D&);
class Vector2D {public: // ...private: double x_, y_;};
Vector2D operator*(const Vector2D &, double);
double operator*(const Vector2D&, const Vector2D&);
Vector2D.hVector2D.hVector2D operator*(const Vector2D&, double s) { return Vector2D( v.x() * s, v.y() * s); }
double operator*(const Vector2D& v1, const Vector2D& v2) { return ( v1.x() * v2.x() + v1.y() * v2.y() ); }
Vector2D operator*(const Vector2D&, double s) { return Vector2D( v.x() * s, v.y() * s); }
double operator*(const Vector2D& v1, const Vector2D& v2) { return ( v1.x() * v2.x() + v1.y() * v2.y() ); }
Vector2D.ccVector2D.cc
Overloading di operatori (2)
Permette di utilizzare tipi definiti dall’utente come se fossero tipi fondamentali
La cardinalita`, l’associativita` e la precedenza di un operatore non possono essere modificati
Operatori unari sono implementati come metodi senza argomenti (l’oggetto è l’argomento implicito)
Operatori binari possono essere implementati come metodi con un argomento (il primo argomento, implicito, è l’oggetto il cui operatore agisce) o come funzioni friend a due argomenti.
Programmazione generica
template<class T> T max( T p1, T p2 ) { if ( p1 < p2 ) return p2; else return p1;}
template<class T> T max( T p1, T p2 ) { if ( p1 < p2 ) return p2; else return p1;}
int main() { Vector v1,v2; cout << max<int>(10,20) << endl; cout << max<float>(2.6,1.0) << endl; cout << max<Vector>(v1,v2) << endl;}
int main() { Vector v1,v2; cout << max<int>(10,20) << endl; cout << max<float>(2.6,1.0) << endl; cout << max<Vector>(v1,v2) << endl;}
Main.ccMain.cc
Per il tipo T deve essere definito l’operatore < Per il tipo T deve essere definito l’operatore <
Il C++ fornisce un metodo per creare un polimorfismo parametrico. E’ possibile utilizzare lo stesso codice per tipi differenti: il tipo della variabile diventa un parametro
Sintassi
template < class identifier >
function definition
template < class identifier >
class definition
typenametypename
Ogni volta che nella definizione della funzione o della classe appare identifier questo viene sostituito dal compilatore con il tipo fornito nella chiamata.
La dichiarazione e l’implementazione del template devono essere nello stesso file ove il template viene utilizzato
Parametri interi possono essere inclusi nella dichiarazione del template
I parametri di default possono essere tralasciati
Parametri templati
template <typename T=int , int n=10>
class array_n {
...
private:
T items[n]; // n istanziato esplicitamente
};
array_n<complex, 1000> w; // w array di complessi
Templates di templates
L’argomento di un template puo` essere esso stesso un template
questo permette la creazione e l’utilizzo di meta-templates (templates istanziati con templates) molto sofisticati
la Standard Template Library fa uso di questa possibilita`
template <class T1, template <class T2> class T3 >
Funzioni template e parametri
Una buona parte dei compilatori accetta una sintassi ristretta per quel che riguarda le funzioni template. ANSI/C++ prevede invece che anche parametri numerici possano essere inclusi nella definizione del template
template <class T>void swap(T& x, T& y){
T temp;temp=x;x=y;y=temp;
}
template <class T>void swap(T& x, T& y){
T temp;temp=x;x=y;y=temp;
}
template <class T, int n=10>T aFunc(){
T temp[n];. . .
}
template <class T, int n=10>T aFunc(){
T temp[n];. . .
}
OK per ogni compilatore
ANSI/C++, ma la maggiorparte dei compilatori lo rifiuta
Membri statici
Per le classi template, gli attributi statici non sono universali ma specifici di ogni istanza
Le variabili statiche MyClass<int>::counter e MyClass<double>::counter sono diverse
template <class T>class MyClass {public:
static int counter;
...};MyClass<int> a,b;MyClass<double> c;
template <class T>class MyClass {public:
static int counter;
...};MyClass<int> a,b;MyClass<double> c;
Un esempio: lo stack di interi
val
Contenuto
next
val
Contenuto
next......val
Contenuto
next
Stack
top
Stack
top
Lo stack vuoto
class Contenuto {...private: Contenuto* next; int val; };
class Stack {...private: Contenuto* top;};
class Contenuto {...private: Contenuto* next; int val; };
class Stack {...private: Contenuto* top;};
Un esempio: lo stack di interi
class Stack {public: Stack() {top = 0;} ~Stack() {} void push ( int i ) { Contenuto* tmp = new Contenuto(i,top ); top = tmp; } int pop () { int ret = top->getVal(); Contenuto* tmp = top; top = top->getNext(); delete tmp; return ret; }private: Contenuto* top;};
class Stack {public: Stack() {top = 0;} ~Stack() {} void push ( int i ) { Contenuto* tmp = new Contenuto(i,top ); top = tmp; } int pop () { int ret = top->getVal(); Contenuto* tmp = top; top = top->getNext(); delete tmp; return ret; }private: Contenuto* top;};
class Contenuto {public: Contenuto ( int i, Contenuto* ptn ) { val=i; next=ptn; } int getVal (){ return val; } Contenuto* getNext() {return next;}private: Contenuto* next; int val; };
class Contenuto {public: Contenuto ( int i, Contenuto* ptn ) { val=i; next=ptn; } int getVal (){ return val; } Contenuto* getNext() {return next;}private: Contenuto* next; int val; };
int main() {Stack s;s.push ( 10 );s.push ( 20 );cout << s.pop() << “ - “ << s.pop;return 0;};
int main() {Stack s;s.push ( 10 );s.push ( 20 );cout << s.pop() << “ - “ << s.pop;return 0;};
User codeUser code
>> 10 - 20>> 10 - 20
OutputOutput
Lo stack “templato”
template <class T>class Stack {public: Stack() {top = NULL;} ~Stack() {;} void push ( T i ) { Contenuto<T>* tmp = new Contenuto<T> (i,top ); top = tmp; } T pop () { T ret = top->getVal(); Contenuto<T>* tmp = top; top = top->getNext(); delete tmp; return ret; }private: Contenuto<T>* top;};
template <class T>class Stack {public: Stack() {top = NULL;} ~Stack() {;} void push ( T i ) { Contenuto<T>* tmp = new Contenuto<T> (i,top ); top = tmp; } T pop () { T ret = top->getVal(); Contenuto<T>* tmp = top; top = top->getNext(); delete tmp; return ret; }private: Contenuto<T>* top;};
template <class T>class Contenuto {public: Contenuto ( T i, Contenuto* ptn ) { val = i; next = ptn; } T getVal (){ return val; } Contenuto* getNext() {return next;}private: Contenuto* next; T val; };
template <class T>class Contenuto {public: Contenuto ( T i, Contenuto* ptn ) { val = i; next = ptn; } T getVal (){ return val; } Contenuto* getNext() {return next;}private: Contenuto* next; T val; };
int main() {Stack<int> s;s.push ( 10 );s.push ( 20 );Stack<double> s1;Stack<Shape *> s2;cout << s.pop() << “ “ << s.pop;return 0;};
int main() {Stack<int> s;s.push ( 10 );s.push ( 20 );Stack<double> s1;Stack<Shape *> s2;cout << s.pop() << “ “ << s.pop;return 0;};
User codeUser code
La Standard Template Library
vettori, liste, mappe, ….vettori, liste, mappe, ….
find, replace, reverse, sort, …. find, replace, reverse, sort, ….
puntatori intelligentipuntatori intelligenti
La libreria standard STL e’ una libreria di classi di contenitori, algoritmi ed iteratori.
STL e’ una libreria generica: tutti i suoi componenti sono parametrizzati mediante l’utilizzo dei template
Gli iteratori sono dei puntatori agli elementi di un contenitore e ci permettono di muoverci all’interno di esso:– Iteratori monodirezionali: Permettono di accedere
all’elemento successivo o al precedente– Iteratori bidirezionali : Permettono di accedere sia
all’elemento successivo che al precedente– Iteratori ad accesso casuale : Permettono di accedere
ad un qualunque elemento del contenitore
Iteratori (puntatori intelligenti)
Un contenitore è un oggetto capace di immagazzinare altri oggetti e che possiede metodi per accedere ai suoi elementi. – Ogni contenitore ha un iteratore associato che permette
di muoversi tra gli elementi contenuti– Una sequenza è un contenitore di lunghezza variabile i
cui elementi sono organizzati linearmente. E’ possibile aggiungere e rimuovere elementi
– Un contenitore associativo è una sequenza che permette un efficiente accesso ai suoi elementi basato su una chiave.
Contenitori
Sequenze
vector– Tempo costante di inserimento e cancellazione di
elementi all’inizio e alla fine del vettore.– Tempo lineare con il numero di elementi per
inserimento e cancellazione di elementi all’interno del vettore
– Iteratore ad accesso casuale
list– Tempo costante di inserimento e cancellazione di
elementi in ogni punto della lista– Iteratore bidirezionale
vector
11 22 ...... 99
begin()begin() end()end()
pppp pp pp pp
00 push_back()push_back()
pp++++
Le locazioni di memoria sono contigue– Accesso casuale, veloce l’accesso agli elementi,
lenti inserimento ed estrazione
val
nodo
next
prev
list
Simile allo stack, ma consente di muoversi in due direzioni
Le locazioni di memoria non sono contigue– Lenta la ricerca, veloci inserimento ed estrazione
......list
top
val
nodo
next
prev
val
nodo
next
prevbottom
Contenitori associativi
Sono contenitore di coppie ( key, value ) e possiedono un iteratore bidirezionale
map– Viene richiesto l’operatore < per la chiave– Gli elementi sono ordinati secondo la chiave
Algoritmi
Gli algoritmi sono delle funzioni globali capaci di agire su contenitori differenti
Sono incluse operazioni di ordinamento (sort, merge, min, max...), di ricerca (find, count, equal...), di trasformazione (transform, replace, fill, rotate, shuffle...), e generiche operazioni numeriche (accumulate, adjacent difference...).
find
count copy
fillsort
min, max
#include < >#include <algorithm>#include <iostream>
int main() {
<int> container;int val;for (int i=0; i<10; i++) { val = (int)((float)rand()/RAND_MAX*10); container.push_back(val); } <int>::iterator it1;for ( it1=container.begin(); it1!=container.end(); it1++) cout << "vector : " << *it1 << endl;return 0;}
Esempio uso sequenze
vector
vector
vector
list
list
list
#include <map> #include <algorithm> #include <iostream> #include <string> int main() { map<string,int> amap; amap["Primo”]=1; amap[“Secondo”]=2; cout << "Size : " << amap.size() << endl; amap["Terzo"]=3; amap["Quarto"]=4; cout << "Size : " << amap.size() << endl; map<string,int>::iterator it; for ( it=amap.begin(); it!=amap.end(); it++) cout << "map : " << it->first << " " << it->second << endl; cout << amap.find("Terzo")->second << endl; return 0; }
#include <map> #include <algorithm> #include <iostream> #include <string> int main() { map<string,int> amap; amap["Primo”]=1; amap[“Secondo”]=2; cout << "Size : " << amap.size() << endl; amap["Terzo"]=3; amap["Quarto"]=4; cout << "Size : " << amap.size() << endl; map<string,int>::iterator it; for ( it=amap.begin(); it!=amap.end(); it++) cout << "map : " << it->first << " " << it->second << endl; cout << amap.find("Terzo")->second << endl; return 0; }
Esempio uso contenitori associativi
Assegnazione di un metodo ad un messaggio
I metodi pubblici di una classe costituiscono l’interfaccia della classe (cioè i messaggi che l’oggetto può interpretare)
La funzione è assegnata al messaggio in fase di codifica (early binding)
Può essere necessario assegnare la funzione al messaggio a run-time (late binding)
Polimorfismo
Controllo dei tipi
Controllare i tipi significa verificare che ad un oggetto vengano inviati solo messaggi che è in grado di comprendere:– controllo del nome del metodo– controllo della lista degli argomenti
In C++ il controllo è fatto dal compilatore (strong typing)
In altri linguaggi (ad esempio SmallTalk) è fatto a run-time (weak typing)
Typing & Binding
TypingDefinizionedei messaggie degli argomenti
BindingAssegnazionedi un metodo
ad un messaggio
StrongConsistenza deitipi verificatadal compilatore
Weak Consistenza deitipi verificata
a run-time
EarlyIn fase di
programmazione INFLESSIBILE
Late A run-time
POLIMORFISMO
Esempio: i soldati
Tutti i soldati devono capire il messaggio attacca. Il messaggio ha conseguenze diverse a seconda del tipo di soldato:– un arcere lancia una freccia– un fante usa la spada– un cavaliere lancia una lancia
Il gestore della schermata vuole tenere una lista di soldati e vuole poter dire ad ogni soldato di attaccare indipendentemente dal tipo ma basandosi solo sulla posizione.
list<Soldato> lista;
riempiLista(lista);
Posizione unaPosizione=...;
list<Soldato>::iterator iter;
for(iter=lista.begin();iter!=lista.end();iter++){
Soldato unSoldato=(*iter);
if(unSoldato.posizione()==unaPosizione) unSoldato.attacca();
}
class Soldato {
void attacca() {
// cosa scrivo qui?!? Per quale tipo di
// soldato implemento il metodo attacca()?
}
};
list<Soldato> lista;
riempiLista(lista);
Posizione unaPosizione=...;
list<Soldato>::iterator iter;
for(iter=lista.begin();iter!=lista.end();iter++){
Soldato unSoldato=(*iter);
if(unSoldato.posizione()==unaPosizione) unSoldato.attacca();
}
class Soldato {
void attacca() {
// cosa scrivo qui?!? Per quale tipo di
// soldato implemento il metodo attacca()?
}
};
Polimorfismo
Polimorfismo con tipi controllati dal compilatore (Strong typing & late binding).
Come? In C++ viene implementato tramite il
concetto di ereditarietà (inheritance) Classe astratta: definisce i messaggi Classe concreta: assegna i metodi ai
messaggiLa classe concreta eredita da quella astratta
Ereditarietà
Una classe può essere derivata da una classe esistente usando la sintassi:
– public, protected e private specificano il tipo di accesso ai membri della classe
Se la classe base non ha un costruttore di default:– La classe derivata deve implementarlo
Se la classe base ha un costruttore di default:– il costruttore della classe derivata deve esplicitamente
invocarlo nella sua lista di inizializzatione Il costruttore della classe base può così essere eseguito prima
che il costruttore della classe derivata sia eseguito
class newclass: (public|protected|private) oldclass {dichiarazioni...};
Ereditarietà (2)
Una classe derivata pubblicamente è a tutti gli effetti un sottotipo della classe base. – Un oggetto della classe derivata può essere trattato
come se fosse un oggetto della classe base– Un puntatore alla classe base può puntare ad oggetti
della classe derivata– Un riferimento alla classe derivata può, se la cosa ha un
senso, essere implicitamente convertito ad un riferimento alla classe base
– E` possibile dichiarare un riferimento alla classe base ed inizializzarlo ad un oggetto della classe derivata
Ereditarietà (3)
La definizione dell’interfaccia (metodi pubblici) della classe base è estremamente importante perchè determina il comportamento delle classi derivate
Un metodo della classe base può essere:– dichiarato e definito normalmente
la classe derivata eredita questo metodo e NON può ridefinirlo
– dichiarato virtual e definito normalmente la classe derivata eredita questo metodo e può ridefinirlo
– dichiarato virtual e non definito (=0) la classe derivata eredita il metodo e DEVE ridefinirlo
Classi base astratte
Una funzione puramente virtuale è un metodo virtuale non definito. E` dichiarato come:
Una classe che ha almeno un metodo puramente virtuale è chiamata classe astratta
Oggetti di una classe astratta non possono esistere Puntatori ad una classe base astratta possono
essere definiti ed usati polimorficamente (per puntare ad oggetti delle classi derivate)
Una classe base astratta viene introdotta per specificare l’interfaccia di una categoria di classi
virtual func_prototype = 0;
class Soldato {
virtual void attacca()=0;
};
class Arcere : public Soldato {
virtual void attacca() {
// lancia una freccia
}
};
class Fante : public Soldato {
virtual void attacca() {
// usa la spada
}
};
...
class Soldato {
virtual void attacca()=0;
};
class Arcere : public Soldato {
virtual void attacca() {
// lancia una freccia
}
};
class Fante : public Soldato {
virtual void attacca() {
// usa la spada
}
};
...
Erediarietà multipla
L’ereditarietà multipla permette di derivare una classe da due o più classi base. La sintassi viene estesa per permettere una lista di classi base
L’ ereditarietà multipla viene spesso utilizzata per combinare un’interfaccia ed una implementazione, ma è molte volte sintomo di un cattivo disegno
class A {. . . .};class B {. . . .};
class AplusB: public A, private B {. . . .};
class Base {. . . . // base implementation};class Derived: public Base {. . . .
void new_method() ; // non e’ definito in Base!};void func(Base *ptr) // ptr e’ un obbetto dell classe Base{ ptr->new_method(); // Errore!!!
Derived *p = dynamic_cast<Derived *> (ptr)if (p !=0) {
p->new_method();}
}
dynamic_cast
dynamic_cast opera una conversione, se è possibile, fra due tipi. Il puntatore ritornato NON è nullo soltanto se il tipo dell’oggetto su cui si opera è quello che ci si aspetta
Ereditarietà (4)
Una classe derivata estende la classe base e ne eredita tutti i metodi e gli attributi
class Track{public: LorentzVector momentum() { return p_; }
protected: LorentzVector p_;};
class Track{public: LorentzVector momentum() { return p_; }
protected: LorentzVector p_;};
Track.hTrack.h
#include “Track.h”
class DchTrack : public Track{public: int hits() { return hits_->size(); }
DchHit* hit(int n) { return hits_[n]; }
protected: list<DchHit> hits_;};
#include “Track.h”
class DchTrack : public Track{public: int hits() { return hits_->size(); }
DchHit* hit(int n) { return hits_[n]; }
protected: list<DchHit> hits_;};
DchTrack.hDchTrack.h
DchTrack è una Track che ha degli attributi in più (hits_) e nuovi metodi (DchHit* hit(int n), int hits())
Esempio: shape
Tutti gli oggetti nella finestra hanno comportamenti comuni che possono essere considerati in astratto:
– disegna– sposta– ingrandisc – etc...
Cerchi e quadrati
Quadrato Cerchio
Circle.h
Cerchio
CostruttoreCostruttore
DistruttoreDistruttore
Nome della classeNome della classe
Punto e virgolaPunto e virgola!!
Point2dPoint2d: classe che rappresenta : classe che rappresenta un punto in 2 dimensioni.un punto in 2 dimensioni.
public: Circle(Point2d center, double radius); ~Circle(); void moveAt(const Point2d & p); void moveBy(const Point2d & p); void scale(double s); void rotate(double phi); void draw() const; void cancel() const;
““Dati” privatiDati” privati((AttributiAttributi, membri), membri)
class Circle {
};
private: Point2d center_; double radius_;
Interfaccia PubblicaInterfaccia PubblicaMetodiMetodi: operazioni sugli : operazioni sugli
oggettioggetti
Cerchio (2)#include “Circle.h”
void Circle::draw() const { const int numberOfPoints = 100; float x[numberOfPoints], y[numberOfPoints]; float phi = 0, deltaPhi = 2*M_PI/100; for ( int i = 0; i < numberOfPoints; ++i ) { x[i] = center_.x() + radius_ * cos( phi ); y[i] = center_.y() + radius_ * sin( phi ); phi += dphi; } polyline_draw(x, y, numberOfPoints, color_, FILL);}
void Circle::moveAt( const Point2d& p ){ cancel(); center_ = p; draw(); }
void Circle::scale( double s ) { cancel(); radius_ *= s; draw(); }
Circle::Circle( Point2d c, double r ) : center_( c ), radius_( r ) { draw(); }
Circle::~Circle() { cancel(); }
Circle.cc
#include “Circle.h”int main() { Circle c( Point2d(10, 10), 5 ); c.draw(); c.moveAt(Point2d(20, 30)); return 0;}
Main.cc
Quadrato
class Square {public: Square(const Point2d&, const Point2d&, Color color = TRASPARENT); ~Square(); void moveAt( const Point2d& p ); void moveBy( const Point2d& p ); void changeColor( Color color ); void scale( double s ); void rotate( double phi ); void draw() const; void cancel() const;
private: Point2d center_; Vector2d centerToUpperCorner_; Color color_;};
Square.h#include “Square.h”
void Square::draw() const { float x[4], y[4]; Vector2d delta( centerToUpperCorner_ ); for ( int i = 0; i < 4; i++ ) { Point2d corner = center_ + delta; x[i] = corner.x(); y[i] = corner.y(); delta.rotate( M_PI_2 ); } polyline_draw(x, y, 4, color_, FILL);} void Square::rotate( double phi ) { cancel(); centerToUpperCorner_.rotate( phi ); draw(); }
Square::Square(const Point2d& lowerCorner, const Point2d& upperCorner, Color color) : center_( median(lowerCorner, upperCorner) ), centerToUpperCorner_( upperCorner - center_ ), color_( color ) { draw(); }
void Square::scale( double s ) { cancel(); centerToUpperCorner_ *= s; draw(); }
Square.cc
upperCornerupperCorner
loweCornerloweCorner
centerToUpperCornercenterToUpperCorner__
Codice Applicativo (Client)
#include “Circle.h”#include “Square.h”
int main() { Circle c1( Point2d(2.,3.), 4.23 ); Square r1( Point2d(2.,1.), Point2d(4.,3.) );
Circle * circles[ 10 ]; for ( int i = 0; i < 10; ++i ) { circles[ i ] = new Circle( Point2d(i,i), 2. ); } for ( int i = 0; i < 10; ++i ) circles[ i ]->draw();
return 0;}
Main.cc
Come gestire cerchi Come gestire cerchi e quadrati insieme?e quadrati insieme?
Costruisce un vettore di puntatori a Costruisce un vettore di puntatori a cerchi, crea oggetti in memoria e salva cerchi, crea oggetti in memoria e salva i loro puntatori nel vettore. i loro puntatori nel vettore.
Itera sul vettore e invoca Itera sul vettore e invoca drawdraw()() per ogni elementoper ogni elemento
Polimorfismo
Tutte le Tutte le ShapeShapesshanno la stessa interfaccia:hanno la stessa interfaccia:draw, pick, move, fillColor...draw, pick, move, fillColor...,,ma ogni ma ogni sottotiposottotipo diverso diversopuò avere la usa personalepuò avere la usa personaleimplementazioneimplementazione
class Shape {public: Shape() { } virtual ~Shape() { } virtual void moveAt(const Point2d& where) = 0; virtual void changeColor(Color newColor) = 0; virtual void scale(double s) = 0; virtual void rotate(double phi) = 0; virtual void draw() const = 0; virtual void cancel() const = 0;};
Shape.h
Interfaccia astratta
Interfaccia di metodi Interfaccia di metodi puramente virtualipuramente virtuali
#include “Shape.h”
class Square : public Shape { // …. Il resto tutto uguale a prima};
Square.h
#include “Circle.h”#include “Square.h”
int main() { Shape * shapes[ 20 ]; int index = 0; for ( int i = 0; i < 10; i++ ) { Shape * s; s = new Circle( Point2d(i, i), 2.) ); shapes[ index ++ ] = s; s = new Square( Point2d(i, i), Point2d(i+1, i+2)) ); shapes[ index ++ ] = s; }
for ( int i = 0; i < 20; i++ ) shapes[ i ]->draw();
return 0;}
Main.cc
Ereditarietà e riuso del codice
Class CenteredShape: public Shape {public: CenteredShape(Point2d c, Color color = TRASPARENT) : center_(c), color_(color) { /*draw();*/ } ~Circle() { /*cancel();*/ } void moveAt( const Point2d& ); void moveBy( const Vector2d& ); void changeColor( Color ); virtual void scale( double ) = 0; virtual void rotate( double ) = 0; virtual void draw() const = 0; virtual void cancel() const = 0;
protected: Point2d center_; Color color_;};
CenteredShape.hNon si possono chiamare Non si possono chiamare metodi virtuali in costruttori e metodi virtuali in costruttori e distruttori distruttori (troppo presto, (troppo presto, troppo tardi)troppo tardi)
#include “CenteredShape.hh”
class Square : public CenteredShape {public: Square( Point2d lowerCorner, Point2d upperCorner, Color col = TRASPARENT) : CenteredShape( median(lowerCorner, upperCorner), col), touc_(upperCorner - center_) { draw(); } ~Square() { cancel(); } virtual void scale( double s ) { cancel(); centerToUpperCorner_ *= s; draw(); } virtual void rotate( double phi ); virtual void draw() const; virtual void cancel() const;
private: Vector2d touc_;};
Square.h
Attenzione alle generalizzazioni...
class Rectangle {public: Rectangle(double x0, double y0, double lx, double ly) : lx_(lx), ly_(ly), x0_(x0), y0_(y0) { } void scaleX(double s); void scaleY(double s);protected: double x0_, y0_; double lx_, ly_;};
Rectangle.h Attenzione: scegliere le relazioni di ereditarietà può essere non banale.
Un quadrato è un rettangolo?
class Square : public Rectangle{public: Square(double x0, double y0, double l) : Rectangle(x0, y0, l, l) { }};
Square.h
Avere lx_ e ly_ è ridondante per SquareCosa succede se si invoca scaleX o scaleY ?
Avere lx_ e ly_ è ridondante per SquareCosa succede se si invoca scaleX o scaleY ?
Ereditarietà multipla
Una classe può ereditare da più classi
class DrawableObj{public: virtual void draw() = 0;};
DrawableObj.h
class Shape {public: virtual void scale(double s) = 0; virtual void moveAt( Vector2d& ) = 0;};
Shape.h
class DrawableShape : public DrawableObj, public Shape{public: virtual void draw(); virtual void scale(double s); virtual void moveAt( Vector2d& ); };
DrawableShape.h
Strategie di sviluppo di un progetto
Requisiti: cosa l’utente vuole Analisi: la visione dell’informatico dei requisiti Disegno: l’aspetto del sistema software Produzione: codifica Testing: debugging e verifica dei requisiti Mantenimento: installazione del prodotto e
controllo del funzionamento per il resto della sua vita
Modello a cascata
Analisi
Disegno
Produzione
Testing
Requisiti
Modello evoluzionario
Requisiti
Analisi
Disegno
Produzione
Testing
Confronto fra i modelli di sviluppo
A cascata Processo lineare (si torna al
passo precedente solo in caso di problemi)
Confinamento delle attività in ogni fase
Facile da gestire (gestione delle scadenze)
Difficile da modificare Prodotto utilizzabile solo alla
fine del processo
Evoluzionario Processo ciclico (brevi
processi completi) Attività distribuite su più fasi Difficile da gestire Facile da modificare e
integrare Prototipo utilizzabile fin dal
primo ciclo
Requisiti
Definizione delle richieste da parte dell’utente del programma (o di una sua parte) sul sistema
Si parla di programmazione per contratto perchè l’utente richiede solamente la definizione del servizio richiesto NON la metodologia seguita per fornirglielo– è possibile delegare parte del lavoro richiesto ad
altri– il sistema è indipendente da chi è il suo utente
INCAPSULAMENTO!
Analisi
Comprensione e razionalizzazione delle richieste dell’utente
Costruzione di un modello– astrazione (semplificazione delle relazioni)– rilevanza (identificazione degli oggetti chiave)
Da non trascurare: analisi delle soluzioni esistenti. Può far risparmiare molto tempo!!!
Disegno
Definizione delle interfacce
Definizione di oggetti e classi
Definizione degli stati e dell’implementazione
Definizione delle relazioni
Disegno (2)
Dopo ogni ciclo bisogna analizzare i rischi, la stabilità del disegno e la complessità delle classi
Se una classe è troppo complessa conviene dividerla
Ad ogni ciclo il numero di modifiche deve diminuire
Architetture troppo complesse devono essere modularizzate
Codifica
C’è poco da dire… Non sopravvalutate questa fase:
Suddivisione del tempo per il primo ciclo
Analisi30%
Disegno35%
Codifica15%
Testing20%
Testing
Debugging: è ovvio… il codice non deve dare errori.
Use cases: specificano il comportamento del sistema in una regione.
Scenarios: sono esempi concreti di use cases. Per definizione se tutti gli scenari sono soddisfatti correttamente il test è positivo.
Metodi di sviluppo del software
Un metodo comprende: Una notazione
mezzo comune per esprimere strategie e decisioni
Un processospecifica come deve avvenire lo sviluppo
Metodi Object Oriented
– Booch Methodby Grady Booch
– OMT by Jim Rumbaugh
– Objectory (Use Cases) by Ivar Jacobson
– CRC by R.Wirfs-Brock
Di recente introduzione: UML– uno standard OMG (Object Management Group),
dal novembre 1997
Grady Booch
Jim Rumbaugh
Ivar Jacobson
UML per l’analisi e il disegno
Class Diagrams: aspetto statico del sistema. Classi con attributi e metodi e relazioni tra di esse.
Sequence e collaboration digrams: comportamento dinamico del sistema. Sequenza dei messaggi scambiati fra gli oggetti.
Use case diagrams: illustra gli use cases, le relazioni fra di essi e gli attori che vi partecipano.
State diagrams: descrive gli stati in cui ogni oggetto si può trovare e le modalità con cui passa da uno stato all’altro
Concetti delle classi rivisitati
Relazioni tra oggetti Decomposizione funzionale all’interno di una
classe– responsabilità dei metodi
Decomposizione funzionale tra più classi– responsabilità delle classi
Rappresentazione delle classi
Nome
+ metodo(arg)# metodo(arg)- metodo(arg)
- dato- dato
operatori
attibutipubblico
protetto
privato
Rappresentazione di una classe C++ in UML
class Nome {private: Tipo1 variabile1; Tipo2 variabile2; Tipo3 variabile3;public: Nome(); ~Nome(); Tipo4 funzione1 ( arg );protected: Tipo5 funzione2 ( arg );private: Tipo6 funzione3 ( arg );};
Nome.h Nome
- variabile1:Tipo1 - variabile2:Tipo2 - variabile3:Tipo3
+ funzione1(arg):Tipo4# funzione2(arg):Tipo5- funzione3(arg):Tipo6
Attributi e metodi
Plane
_distance : double_nor : Vector_origin : Point
distance()derDist()
Surface
id : int
distance()derDist()
Cylinder
Publico (+)
Privato (-)
Protetto (#)
Notazione di Rational Rose
Principali relazioni fra classi
associazione aggregazione by reference
(il composito non vive senza il componente)
aggregazione by value (aggregazione fisica: esistenza contemporanea)
dipendenza generalizzazione (inheritance)
Aggregazione (contenimento)
By reference (condivisa)• un autista guida più automobili
By value (possesso)• una automobile possiede il suo motore
Autista
Motore
Automobile
Cardinalità e direzionalità
PointPolygone
1 1..*1..*1
-_points
•Il punto non conosce i poligoni•Il poligono è costituito da punti
Non navigabile
Dipendenza
CDPlayer
play(CD& theCd)
CD
Non c’è nessuna associazione C’è comunque relazione di uso
•Il CD non conosce il CDPlayer•Il CDPlayer usa il CD: se cambia il formato del CD il CDPlayer deve essere modificato
Generalizzazione (ereditarietà)
{virtual}
AutoSportiva AutoDiLusso
Ferrari
Autista
Automobile
#_autista
Motore
#_motore
{virtual}
Ereditarietàvirtuale!
Class Diagram di “Shape”
Shape
draw()cancel()moveBy()
Circle
radius_ : double
draw()
Point2d
CenteredShape
moveBy()1 11
Square
CenterToUpperCorner_ : Vector2d
draw()
relazione di aggregazione
relazioni di ereditarietà
classi concrete
classi astratte
1
Class Diagram
Class Diagram
Object Sequence Diagram
Object Collaboration Diagram
CRCClassi, Responsabilità, Collaborazioni
C
DE
F
BA
xy
zs
f q
p
w
Assegnare Responsabilità
Identificare i protagonisti Analizzare il ruolo dei vari oggetti Concentrarsi sul comportamento non la
rappresentazione Cercare Oggetti con proprietà comuni:
– appartiene a classi diverse, o sono solo oggetti diversi?
Definire le interfacce (le operazioni che soddisfano le responsabilità)
Una corretta assegnazione delle responsabilità è la chiave di una buona modularità e riuso
Collaborazione tra classi
Le responsabilità vanno suddivise tra i vari oggetti del sistema
non deve esistere un controllo centralizzato Un oggetto deve compiere le proprie
responsabilità e delegare ad altri operazioni specifiche– Legge di Demeter: non usate oggetti lontani:
Invece di: traiettoria.listapunti().aggiungi(Punto);
usare: traiettoria.aggiungiPunto(Punto);
Identificare Relazioni
Cercare collaborazioni Cercare aggregazioni Cercare generalizazioni
Come un client conosce il suo service provider?
Relazioni
Logiche
Generalizazione: Is-a
Aggregazione: Has
Dipendenza: Knows
Implementazione
Inheritance Template
instantiation
Composizione by value
Composizioneby reference
{
Avere o essere?
Uno dei punti critici è distinguere se il rapporto fra due oggetti è del tipo avere o essere:– Un LorentzVector è un Vector o ha un
Vector?– Una Traccia è un vector<Hit> o ha un
vector<Hit>?– Un Rivelatore è una Superficie o ha una
superficie?
Per risolvere il problema bisogna guardare a cosa fanno!
Principio di Liskov
Gli oggetti figli possono essere usati ovunque l’oggetto genitore è richiesto
– usare l’inheritance quando è richiesto il polimorfismo
– Non cambiare il comportamento della base class
Composizione by value o by refrence
In C++ la scelta fra aggregazione by value o by refrence può seguire questo schema:– Tipi semplici (int, float, …): by value– Parte dello stato dell’oggetto: by value– Oggetti condivisi: by reference– Assegnati a run time: by reference
Oggetti condivisi by reference: attenzione a chi ha la responsabilità di crearli e cancellarli! (1 new 1 delete!)
Approccio Outside-in
Il corretto approccio è quello di guardare il sistema dall’esterno.
Identificare prima di tutto gli oggetti che interagiscono con l’utente esterno e i messaggi a cui devono saper rispondere (think client!)
In seguito identificare gli oggetti che forniscono servizi a questi ultimi e così via
Gli algoritmi vengono per ultimi!!!
CRC Workshop
Metodo per la definizione si una architettura bilanciata
Ogni partecipante svolge il ruolo di una classe.– Individuazione delle classi– Contrattazione delle responsabilità– Definizione delle collaborazioni– Difesa dal tentativo di assegnazione di
responsabilità contrarie alla natura della classe
Regole per il CRC workshop
Tentate di rifuutare le responsabilità– Dovrei? (Non sono io che lo devo fare!)– Potrei? (Non ho i mezzi, o lo stato per farlo!)
Cercate di fare poco lavoro– Se avete dovuto accettare una responsabilità cercate
di far fare il lavoro a qualcun’altro
Potenziate i collaboratori, non interferite
Design Patterns
Sono elementi di software OO riutilizzabile Piccoli insiemi di classi che collaborano
implementando dei comportamenti tipici– Creational patterns– Structural patterns– Behavioral patterns
I principali sono raccolti in un libro:
E. Gamma et al., Design Patterns
Factory
AbstractProduct
ConcreteProduct1 ConcreteProduct2
Factory
createProduct1 () : AbstractProductcreateProduct2 () : AbstractProduct
Client
I client possono richiedere la creazione di un prodotto senza dipendervi
La Factory dipende dai prodotti concreti, mentre i client dipendono solo da quelli astratti
Proxy
Subject
request( )
RealSubject
request( )
Proxy
_subject : RealSubject
request( )11
Client
_subject
. . ._subject->request();. . .
Una richiesta da un client a un server, può essere mediata dal Proxy, che può compiere anche altre operazioni (I/O, caching, etc.)
Composite
Leaf
operation( )
Component
operation( )
Composite
operation( )
1..*1..*
Client
for c in all _children c->operation();
_children
Il client può trattare componenti e compositi usando la stessa interfaccia. La composizione può essere ricursiva.
Esempio: programmi di grafica
Gruppo di Shapes
Circle, Square, ...
draw( )
Shape
draw( )
GroupofShapes
draw( )
1..*1..*
Client
_components
Il gruppo di shapes è il Composite
La shape è il Component
Le shapes concrete (Circle, Square, ecc...) sono le Leaf
#include “Shape.h”class Circle: public Shape {public: Circle(Point2D c, double r): Shape(), center_(c), radius_(r) {} void draw() const { ; // draw circle } // altri metodi definiti per Circleprivate: double radius_; Point2D center_;};
Circle.h
Codice del modello composite
class Shape {public: Shape() {} virtual void draw() const = 0; // altri metodi virtuali ( = 0 )};
Shape.h
Codice del modello composite
#include “Shape.h”class GroupofShapes : public Shape {public: typedef vector<Shape *> Container; typedef Container::const_iterator Iterator; GroupofShapes(){} void draw() const { Iterator p=components.begin(); Iterator pe=components.end(); while (p!=pe) { (*p)->draw(); p++; } return; } // gli altri metodi sono definiti operando // sui componentiprotected: Container components;};
GroupofShapes.h
Strategy
Il pattern Strategy permette di scegliere l’algoritmo da eseguire a run-time.
Nuovi algoritmi possono essere introdotti senza modificare il codice utente.
ConcreteStrategyA
doAlgorithm( )
ConcreteStrategyB
doAlgorithm( )
ConcreteStrategyC
doAlgorithm( )
Client Strategy
doAlgorithm( )
{ . . . Strategy* s; s->doAlgorithm(); . . .}
Observer
Observer
update( )Subject
_observers : Observer
attach (Observer)notify ()
0..*0..*
for all o in _observables o->update();
_observers
return _status;_status = _subject->status();
ConcreteSubject
_status : Status
status( )
ConcreteObserver
_status : Status_subject . ConcreteSubject
update( )
_subject
Lo stato dell’Observer dipende dallo stato del Subject.
Il Subject notifica a tutti gli Observer registrati che il suo stato è cambiato.
Appendice: strighe C-style
Le variabili carattere sono gestite come array di char (un char contiene un solo carattere)– accesso agli elementi tramite la sintassi degli array– carattere nullo usato come terminatore (‘\0’)
Funzoni di libreria per la gestione dei char* :– #include<cstring> per utilizzarle– int strlen(const char*); lunghezza della
stringa– int strcmp(const char*, const char*);
confronto di due stringhe– char* strcpy(char*, const char*); copia
la seconda stringa nella prima
Appendice: la classe string
Per semplificare la gestione delle stringhe è stata creata la classe string– #include<string> per usarla– Definiti gli operatori standard:
= per l’assegnazione+ e += per la concatenazione== e tutti gli altri operatori relazionali per il confronto[] per l’accesso agli elementi
– Disponibile sintassi simile a quella dei contenitori STL: iteratori: string::iterator e string::const_iterator funzioni begin() , end() , size() , ecc...
– Interoperabilità con char*: char* c=“Pippo”; string s=c;
char* c1 = s.c_str(); s += c;
Confronto stringhe C-style e string#include<iostream>
#include<cstring>
int main(){
int err=0;int big=1000000;
char* c1=“LLLong string”;
for(int i=0;i<big;i++){
int len=strlen(c1);
char* c2=new char[len+1];
strcp(c2,c1);
if(strcmp(c2,c1))err++;
delete[] c2;
}
cout<<err<<“errori”<<endl;
return 0;
}
#include<iostream>
#include<string>
int main(){
int err=0;int big=1000000;
string s1=“LLLong string”;
for(int i=0;i<big;i++){
// int len=s1.size();
string s2=s1;
if(s2!=s1)err++;
}
cout<<err<<“errori”<<endl;
return 0;
} // 2 volte piu’ veloce!!!
Appendice:operazioni di I/O
Si utilizza la libreria iostream – Gli operatori di stream >> e << dirigono il flusso
da/per le unità desiderate:cout : standard output. Si sono già visti molti esempicerr : standard error. Si usa come coutcin : standard input (normalmente la tastiera)
include<iostream>include<string>int main(){ string nome; cout << “Come ti chiami?” << endl; cin >> nome; // Notare la direzione!!! if(nome.empty()) cerr << “Stringa nulla!” << endl; else cout << “Ciao “ << nome << “!” << endl; return 0;}
Overloading degli operatori di I/O
Gli operatori << e >> possono essere ridefiniti per consentire operazioni del tipo:
Vector2D v(1,2);
cout << “Il vettore v vale “ << v << endl;
Si utilizza una funzione friend:class Vector2D {
friend ostream& operator <<(ostream& os, const Vector2D v);
[...]
}
ostream& operator <<(ostream& os, const Vector2D v){ os << “(“ << v.x() << “,” << v.y() << “)”;}
Si ottiene:Il vettore v vale (1,2)
Appendice: I/O con files
E’ possibile definire altre unità di I/O– Si utilizza la libreria fstream (include iostream)– I files di input sono dichiarati ifstream– I files di output sono dichiarati ofstream– I files di input/output sono dichiarati fstream– Costruttore con argomento const char* (nome
file)#include <fstream>#include <string>int main(){ ifstream fin(“file1.dat”); // deve esistere! if(!fin){ cerr << “file1.dat non esiste” << endl; return -1; } ofstream fout(“file2.dat”); // se esiste viene sovrascritto int i=0; string parola; while (inf >> parola) fout << “La “ << ++i << “-esima parola e\’ “ << parola << endl; fin.close(); fout.close(); return 0;}
Appendice: I/O in memoria
E’ possibile definire unità di I/O in memoria (non legate a files)– Si utilizza la libreria sstream (include iostream)– Le unità di input sono dichiarati istringstream– Le unità di output sono dichiarati ostringstream– Le unità di input/output sono dichiarati stringstream
– I costruttori non hanno argomento– Il metodo str() applicato ad un oggetto di questo
tipo ritorna la stringa (string) contenuta nell’unità:ostringstream messaggio;
messaggio << “Ciao!” << endl;
string s=messaggio.str();
Appendice: Manipolatori di I/O
Modificano il comportamento di una stream.
boolalpha: true e false rappresentati come stringhe noboolalpha: true e false rappresentati come 1 e 0 (default)
showbase: interi stampati col prefisso che indica la base noshowbase: interi stampati senza il prefisso (default)
showpoint: floating point stampati sempre col punto decimalenoshowpoint: stampa i floating point come interi se non frazionari (default)
showpos: stampa + per numeri positivi noshowpos: non stampa + per i numeri positivi (default)
skipws: salta gli spazi bianchi in input (default) noskipws: non salta gli spazi bianchi in input
uppercase: stampa 0X in esadecimale, E in scientifica lowercase: stampa 0x oppure e (default)
dec: interi in base 10 (default) hex: interi in base 16oct: interi in base 8
Appendice: Manipolatori di I/O (2)
I seguenti manipolatori richiedono:#include <iomanip>
left: aggiunge caratteri di riempimento alla destra del val. right: aggiunge caratteri di riempimento alla sinistrainternal: aggiunge caratteri fra segno e valore
fixed: floating point in notazione decimale (default) scientific: floating point in notazione scientifica
flush: svuota il bufferends: aggiunge il carattere nullo (\0) e svuota il buffer endl: aggiunge un “newline” e svuota il bufferws: “mangia” gli spazi bianchi
setfill(ch): definisce il carattere di riempimento
setprecision(n): definisce la precisione per i floating point
setw(n): scrive o legge in n caratteri
setbase(b): interi in base b
Esempio di I/O con manipolatori
Non tutti i compilatori supportano tutti i manipolatori!!!
#include <iomanip>int main() { cout << "inserisci un numero: "; double num=0; while(cin >> num) { int pi = (int)(num); cout << setfill('0') << setprecision(5); cout << "Il numero inserito e\' " << num << endl; cout << "La parte intera e\' " << pi << "(" << hex << setw(6) << pi << " esadecimale)" << dec << endl; cout << "La parte frazionaria e\' " << num-pi << endl; cout << "inserisci un numero: "; } return 0;}
inserisci un numero: 12345.678Il numero inserito e' 12346La parte intera e' 12345(003039 esadecimale)La parte frazionaria e' 0.678inserisci un numero:
Per saperne di più
sugli elementi di base del linguaggio C++**** Lippman, Lajoye, The C++ Primer, 3rd Edition - Addison Wesley
*** Pohl, Object-Oriented Programming Using C++, 2nd Edition - Addison Wesley
*** Stroustrup, The C++ Programming Language, 3rd Edition - Addison Wesley
su trucchi e tranelli in C++**** Myers, Effective C++, Addison Wesley
**** Myers, More Effective C++, Addison Wesley
*** Coplien, Advanced C++, Addison Wesley
su STL**** Glass, Schuchert, The STL <PRIMER>, Prentice Hall
*** Ammeraal, Wiley, STL for C++ Programmers -
** Musser, Saini, STL Tutorial and Reference Guide, Addison Wesley
Per saperne di più (2)
su OO A&D*** Booch, Object-Oriented Analysis and Design with Applications,
Benjamin/Cummings
*** Booch, Object Solutions, Addison Wesley
su UML**** Fowler, Scott, UML Distilled, Addison Wesley
*** Booch, Rumbaugh, Jacobson, The Unified Modeling Language User Guide, Addison Wesley
sui Design Patterns*** Gamma, Helm, Johnson, Vlissides, Design Patterns, Addison
Wesley
LA PROGRAMMAZIONE ORIENTATA LA PROGRAMMAZIONE ORIENTATA AGLI OGGETTI AGLI OGGETTI
JavaJava
PROGETTO DI SISTEMI
Progettare un “sistema software” è cosa ben diversa dal progettare un algoritmo
“CRISI DEL SOFTWARE”: i costi di gestione diventano preponderanti su quelli di produzione
Cosa occorre per ottenere un sistema che non solo funzioni, ma che sia anche “ben fatto”?
SOFTWARE “BEN FATTO” … ?
Ben organizzato Modulare Protetto Riusabile Riconfigurabile Flessibile Documentato Incrementalmente estendibile A componenti
LA COSTRUZIONE DEL SOFTWARE
Ingredienti computazionali– le mosse di un linguaggio
Requisiti– non basta un sistema che “funzioni”
Principi– regole per una buona organizzazione
Modelli, Concetti, Paradigmi, Pattern– fonti di ispirazione
LO SVILUPPO STORICO
1950-1970: – cosa significa computare?– quali mosse primitive deve avere un linguaggio di
programmazione?
1970-1980:– quali principi di organizzazione del software?– basta la programmazione strutturata?
1980-1990:– perché il modello a oggetti è importante?– vi sono alternative alla classificazione?
1990-2000:– quali ripercussioni se la piattaforma
computazionale diventa una rete?– come recuperare vecchie applicazioni
sulle nuove piattaforme?
...
LO SVILUPPO STORICO
PROGETTO & LINGUAGGI
I linguaggi di programmazione devono fornire
non solo un modo per esprimere computazioni
ma anche un modo per dare struttura alla descrizione
e un supporto per organizzare il processo produttivo del software.
PROGETTO & STRUMENTI
PROBLEMA: le strutture dati e le strutture di controllo
(programmazione strutturata) le funzioni e le procedure file e moduli come “contenitori di descrizioni”
non bastano per ottenere softwaremodulare e sviluppabile in modoincrementale. Perché?
LA “CRISI DIMENSIONALE”
Il cambio di dimensioni del problema cambia non solo le “dimensioni fisiche” ma anche le astrazioni, i modelli, gli strumenti più
opportuni per progettare
L’attenzione si sposta
dal singolo algoritmo (e da una o più funzioni)
alle entità del mondo reale da modellare
e agli strumenti che consentono il lavoro di gruppo
LA “CRISI DIMENSIONALE”
Programmi di piccole dimensioni
enfasi sull’algoritmo programmazione strutturata
Programmi di medie dimensioni
funzioni e procedure come astrazioni di espressioni/istruzioni complesse
decomposizione degli algoritmi in blocchi funzionali
LA “CRISI DIMENSIONALE”
Programmi di grandi dimensioni
devono trattare grandi moli di dati, ma la decomposizione funzionale è inadeguata dati e funzioni che elaborano tali dati sono scor-relati:
nulla indica che le una agiscano sugli altri devono essere sviluppati da gruppi, ma
la decomposizione funzionale e il disaccoppia-mento dati/funzioni non agevolano la decompo-sizione del lavoro
(segue)
LA “CRISI DIMENSIONALE”
Programmi di grandi dimensioni (segue)
trattano dati relativi a entità del mondo reale (persone, oggetti, grafici, documenti)
interagiscono con entità del modo reale Tuttavia:
le entità del mondo reale non sono "dati" su cui operano delle funzioni
sono entità che devono essere trattate in modo coerente alla loro essenza
LA “CRISI GESTIONALE”
Il costo maggiore nel processo di produzionedel software è dovuto alla manutenzione
– correttiva (per eliminare errori)– adattativa (per rispondere a nuove esigenze)
Programmi di piccole dimensioni
– trovare gli errori non è difficilissimo
– l’impatto delle modifiche è intrinsecamente limi-tato dalle piccole dimensioni del programma
LA “CRISI GESTIONALE”
Programmi di medie dimensioni individuare gli errori è già più complesso l’impatto delle modifiche si propaga, a causa del non-
accoppiamento dati/funzioni, anche a fun-zioni o procedure diverse da quella modificata.
Programmi di grandi dimensioni trovare gli errori può essere estremamente difficile e
oneroso data la propagazione delle modifiche, ogni
cambiamento coinvolge tutto il team di sviluppo.
LA “CRISI GESTIONALE”
Programmi di medie dimensioni individuare gli errori è già più complesso l’impatto delle modifiche si propaga, a causa del non-
accoppiamento dati/funzioni, anche a fun-zioni o procedure diverse da quella modificata.
Programmi di grandi dimensioni trovare gli errori può essere estremamente difficile e
oneroso data la propagazione delle modifiche, ogni
cambiamento coinvolge tutto il team di sviluppo.
L’OBIETTIVO
Costruzione di software ben organizzato, modulare, protetto, riusabile, riconfigurabile (dinamicamente?), flessibile, documentato, incrementalmente estendibile, …
L'enfasi non è più tutta / solo / prioritariamentesu efficienza e su ottimizzazione.
EFFICIENZA… MA NON SOLO
Premature optimization is the root of all evil– Donald E. Knuth
Make it work first, before you make it work fast– Bruce Whiteside
Make it fail-safe before you make it faster Make it clear before you make it faster
– Kernighan A. Plaugher
QUALE PROGETTO?
Spesso si studia un linguaggio si “pensa” in termini del linguaggio
conosciuto, usando – i costrutti del linguaggio– l’information space del linguaggio– metodologie legate al linguaggio (idiomi,
framework ) – schemi standard (pattern)
Linguaggi: un po’ di storia
Albori: Macchine a programma memorizzato, Programmi come dati
Linguaggio Macchina
Assemblatore
FORTRAN (calcolo scientifico) COBOL (Data Processing)
Anni ’60: Formalizzazione della sintassi, Strutture a blocchi, implementazione del -calcolo
LISP (LISt Processing)
ALGOL
PL/I – ALGOL ‘68(Linguaggio universale)
L’era moderna: Programmazione strutturata, Metodologie, Astrazione, Linguaggi ad alto livello per la programmazione di sistema
PASCAL
C ADAUniversale?
LISP
Varie versioni della logica
PROLOG ML
Programmazione orientata agli oggetti
C++ JAVA
Paradigmi
Per paradigmi di programmazione si intendono i “modi” in cui vengono specificati i programmi
Non si tratta tanto del tipo di linguaggio usato, ma del contesto più ampio al quale un certo linguaggio appartiene
Parliamo di come viene organizzata la programmazione, con quali caratteristiche: stile, livello di dettaglio, “forma mentis” del programmatore
Programmazione non strutturataProgrammazione proceduraleProgrammazione modulareProgrammazione ad oggetti
Paradigmi di programmazione Lezione 1
Programmazione non strutturataLezione 1
Il programma è costituito da un unico blocco di codice detto "main" dentro Il programma è costituito da un unico blocco di codice detto "main" dentro il quale vengono manipolati i dati in maniera totalmente sequenzialeil quale vengono manipolati i dati in maniera totalmente sequenziale
Programmazione proceduraleLezione 1
Il concetto base è quello di raggruppare i pezzi di programma Il concetto base è quello di raggruppare i pezzi di programma ripetuti in porzioni di codice utilizzabili e richiamabili ogni volta ripetuti in porzioni di codice utilizzabili e richiamabili ogni volta che se ne presenti l'esigenza; queste porzioni di codice sono che se ne presenti l'esigenza; queste porzioni di codice sono chiamate procedure. Il programma è costituito da un unico file.chiamate procedure. Il programma è costituito da un unico file.
Programmazione modulareLezione 1
Le procedure aventi un dominio comuneLe procedure aventi un dominio comune (ad esempio, procedure che (ad esempio, procedure che eseguono operazioni matematiche) vengono raggruppate in moduli eseguono operazioni matematiche) vengono raggruppate in moduli separati. Il programma è costituito da più file.separati. Il programma è costituito da più file.
Programmazione orientata agli oggetti (Object Oriented Programming - OOP)
Lezione 1
E’ basato sul fatto che esistono una serie di oggetti che E’ basato sul fatto che esistono una serie di oggetti che interagiscono vicendevolmente, scambiandosi messaggi ma interagiscono vicendevolmente, scambiandosi messaggi ma mantenendo ognuno il proprio stato ed i propri dati.mantenendo ognuno il proprio stato ed i propri dati.
Origini della programmazione ad oggetti
Anni ’60: Simula 1 e Simula 67 Anni ’70: Smalltalk Anni ’80: ADA – consacrazione della
programmazione ad oggetti Tra i più noti linguaggi di programmazione ad
oggetti: Java, C++, Delphi, C#, Visual Basic.NET
Lezione 1
Motivazioni
Migliorare la qualità del software I programmi di grandi dimensioni vengono
scomposti in moduli, che chiameremo oggetti Ne trae beneficio la fase di manutenzione Riutilizzo del codice
Lezione 1
Filosofia del corso
”per me non è importante cheil codice "funzioni", perché io do per scontato che lo faccia. Le cose chemi interessano sono altre, in primissimo luogo la manutenibilità del codicea distanza di anni e da parte di persone diverse“
[un imprenditore IT]
Object Oriented Programming
Introduzione Principi di OOP Classi ed oggetti Attributi, metodi e proprietà Incapsulamento Ereditarietà Polimorfismo Astrazione
A World of Objects Sin dalla loro introduzione negli anni 60, i principi della
programmazione ad oggetti hanno influenzato lo sviluppo del software
La Programmazione Orientata agli Oggetti (OOP) è un paradigma che porta a suddividere un problema complesso in parti (oggetti) in reciproca interazione tramite messaggi
La filosofia di base porta a modellare il mondo reale attraverso entità astratte (il telefono cellulare, una palla che rimbalza, i numeri complessi) in maniera verosimile
Il paradigma ad oggetti
Formalizza mediante le classi il concetto di modulo che incapsula i dati e le procedure per modificarli
Le classi si definiscono in una struttura gerarchica e ereditano caratteristiche e funzionalità
Obiettivo: migliorare l’efficienza del processo di produzione e mantenimento del software
Pilastri della OOP Astrazione
– Il meccanismo con cui si specifica le caratteristiche peculiari di un oggetto che lo differenzia da altri
Incapsulamento dei dati– Il processo di nascondere i dettagli di definizione degli oggetti, solo
le interfacce con l’esterno devono essere visibili Ereditarietà
– Gli oggetti sono definiti in una gerarchia ed ereditano dall’immediato parente caratteristiche comuni, che possono essere specializzate
Polimorfismo– Possibilità di eseguire funzioni con lo stesso nome che pure sono
state specializzate per una particolare classe
Introduzione agli oggetti
Interagiamo con oggetti di uso quotidiano, conoscendone le funzioni, ma non il funzionamento interno
– Gli oggetti sono scatole nere dotate di interfaccia che limita l’accesso ai meccanismi interni
– Gli oggetti hanno uno stato L’insieme delle proprietà che lo caratterizzano in un dato istante
– e un comportamento L’insieme delle azioni che un oggetto può compiere
Un oggetto sw è un’astrazione o un modello della realtà che limita il numero dei dettagli rappresentati all’essenziale per il contesto considerato
What’s in an object Un oggetto è caratterizzato da dei dati, ovvero dal
suo stato;
Fornisce metodi per accedere e manipolare questi dati, determinando il suo comportamento;
Rappresenta una unità reale, cioè la sua identità.
Un esempio:L’oggetto telefono cellulare…
L’oggetto TelefonoCellulare
Lo stato di un telefono cellulare può essere caratterizzato da:
– E’ acceso o spento– In che modalità si trova: stand-by, conversazione,
composizione– Il volume audio, l’ultimo numero digitato.
E’ possibile interagire con il telefono cellulare mediante la tastiera o altri tasti di controllo modificandone lo stato ed il comportamento.
E’ possibile identificare univocamente il telefono cellulare grazie al numero IMEI.
Astrazione
L’astrazione nasconde o ignora dettagli inessenziali
Effettuiamo astrazioni continuamente– Possiamo trattare solo poche informazioni contemporaneamente– Ma se raggruppiamo le informazioni (come gli oggetti) allora
possiamo trattare informazioni più complicate
Un oggetto sw è un’astrazione – Non ci preoccupiamo dei suoi dettagli interni per usarlo– Non conosciamo come funziona il metodo println quando
l’invochiamo
Quindi, possiamo anche scrivere software complesso organizzandolo attentamente in classi e oggetti
Gli oggetti software
Lo stato di un oggetto sw è descritto e rappresentato da una o più variabili– Una variabile è un dato individuato da un
identificatore
il comportamento è definito dai metodi
Un oggetto sw è costituito dall’insieme delle variabili e dei metodi
Oggetti e classi
Gli oggetti sono generati da una classe– Si dicono anche istanze della classe
La classe è uno schema per produrre una categoria di oggetti identici di struttura
– La classe costituisce il prototipo
– La classe descrive le caratteristiche di un oggetto
– Una classe è una fabbrica di istanze: possiede lo schema e la tecnica di produzione
Gli oggetti come astrazione
Un oggetto che modella una bicicletta– Una velocità (20 Km/h), il giro dei pedali (15 g/m)
e la marcia (5°) sono variabili di istanza– proprietà rappresentate in ciascuna bicicletta
modellata
Gli oggetti come astrazione – 2
Inoltre nel modello rappresentiamo funzioni come frenare o cambiare marcia, che modificano le variabili d’istanza
Si chiamano metodi d’istanza perché hanno accesso alle variabili d’istanza e le modificano
Le istanze
Definita una classe, si possono creare un numero arbitrario di oggetti appartenenti alla classe
Incapsulamento dei dati
Nascondere le informazioni fornendo un’interfaccia Le variabili di un oggetto, che ne rappresentano lo stato, sono
nascoste all’interno dell’oggetto, accessibili solo ai metodi
Idealmente i metodi proteggono le variabili 3 diversi livelli di accesso a metodi e variabili
– public: accessibili a chiunque – private: accessibili solo alla classe– protected: accessibili a classe, sottoclassi e pacchetto
Consente modularità e flessibilità
Messaggi (1/3)
Gli oggetti interagiscono tra loro per ottenere funzioni più complesse
– La bicicletta appesa in garage è un oggetto e basta, ci vuole un ciclista che interagisca con lei perché diventi interessante
Gli oggetti sw per interagire si mandano messaggi
– Chiedendo di eseguire un certo metodo
Il ricevente:
Messaggi (2/3)
Spesso i metodi necessitano di informazioni per poter essere eseguiti:i parametri
Tre componenti:– L’oggetto a cui il messaggio è
rivolto: il ricevente– Il metodo da eseguire per
ottenere un certo effetto– I parametri se necessari al
metodo
Il ricevente:
Il messaggio:
Messaggi 3/3 Un oggetto può essere visto come un insieme di servizi che possiamo
chiedere di eseguire
I servizi sono definiti dai metodi
Il comportamento degli oggetti è definito dai suoi metodi e il meccanismo di invio dei messaggi consente l’interazione tra gli oggetti
Gli oggetti che si scambiano i messaggi possono anche essere ‘distanti’ tra loro
– Su macchine diverse– Non appartenenti allo stesso modello
Interfaccia
L’interfaccia è l’insieme dei messaggi che un oggetto è in grado di interpretare
Un oggetto deve soddisfare la richiesta di un messaggio
Eseguendo il metodo si soddisfa la risposta ad un messaggio da parte di un agente
nome: carlomarcia: 5
vel: 20
ciclista_A bicicletta_rossa
cambia (marcia)
Inviare messaggi
Il ciclista ciclista_A che vuole cambiare marcia invia il messaggio all’oggetto bicicletta_rossa
bicicletta_rossa.cambia(2);
oggetto metodo i parametri
informazioni fornite al metodo
Invocazione di un metodo
Molte istruzioni sono invocazioni di metodi su oggetti La sintassi della chiamata del metodo:
Chiediamo il servizio di stampa, invocando il metodo println dell’oggetto System.out
System.out.println (“Hello deep and cruel Java World!");
oggettometodo i parametri
oggetto.nomeMetodo (parametri)
Metodi e oggetti
I metodi possono essere invocati su oggetti della classe che hanno quel metodo nella loro interfaccia
– Il metodo println si può applicare a oggetti della classe PrintStream
System.out.println()
– Il metodo length si può applicare a oggetti della classe String
“salute a tutti”.length()
– Quindi causa errore chiamare:
“salute a tutti”.println()
I membri delle classi
Le classi contengono 2 tipi di membri, definiti per l’intera classe o per le singole istanze– Le variabili o i campi, che rappresentano lo stato
della classe o degli oggetti
– I metodi, che rappresentano il comportamento: codice eseguibile sottoforma di istruzioni
Il tipo di un oggetto è definito dalla classe di appartenenza
Esempio
La classe Point della libreria awt ha due campi, x e y, che rappresentano le coordinate del punto
I campi sono dichiarati public, cioè chiunque acceda alla classe Point può modificarli
Class Point {
public int x, y;
}
La classe Rectangle e i campi d’istanza
I campi x e y rappresentano la posizione dell’angolo alto sinistro e i campi width e height rispettivamente l’ampiezza e l’attezza
Si noti che l’astrazione operata consiste nel considerare un rettangolo come una collezione di 4 valori numerici
La classe predefinita Rectangle
Rectangle
20
15
10
5 x
y
height
width
(x, y)height
width
Creare oggetti
Gli oggetti vengono creati mediante uno speciale metodo di istanziazione, detto costruttore
L’operatore new seguito dal nome della classe istanzia un nuovo oggetto con valori di default dei campi:– new Rectangle()– Costruisce un rettangolo con i 4 campi al valore 0
o con i valori passati come parametri – new Rectangle(5, 10, 15, 20)– Costruisce l’oggetto raffigurato prima
L’operatore new
Si usa per istanziare nuovi oggetti di una classe
È un operatore unario e viene prefisso al proprio argomento: un costruttore della classe
new costruttore_classe() costituisce una espressione
Riporta un valore: un riferimento all’oggetto della classe specificata dal costruttore
Il riferimento viene generalmente salvato in una variabile mediante assegnamento
In memoria
La dichiarazione di una variabile oggetto
Rectangle scatola;
non causa la sua inizializzazione, che va effettuata esplicitamente mediante l’operatore new:
Rectangle
20
15
10
5 x
y
height
width
scatola
scatola
Riferimenti a oggetti
Il riferimento descrive la posizione dell’oggetto sullo heap
Più variabili possono fare riferimento allo stesso oggetto
Rectangle scatola;
scatola = new Rectangle (5,10,15,20);
Rectangle contenitore = scatola; Ora scatola e contenitore si riferiscono allo
stesso oggetto
Errore comune
Dimenticare l’inizializzazione di variabili oggetto
Rectangle mio_rettangolo;
* mio_rettangolo.translate (5, 5);
Saluti_2 salutaCarlo;
* salutaCarlo.diCiao(); Le istruzioni * generano un errore: si applica un metodo a un
oggetto che non esiste ancora La dichiarazione serve solo per creare la variabile oggetto, ma
non per inizializzarla; L’inizializzazione va effettuata esplicitamente mediante la
chimata all’operatore new
Costruttori vs metodi
I costruttori non sono metodi I costruttori non possono essere invocati su oggetti esistenti I costruttori non vengono invocati come i metodi mediante
l’operatore dot (.) I costruttori vengono invocati solo all’atto della generazione di
un oggetto tramite l’operatore new
Errore:
Saluti_2 salutatore_di_Andrea;
* salutatore_di_Andrea.Saluti_2(“Andrea”);
Approccio orientato agli Oggetti (intro)
Pensare e rappresentare problemi usando concetti del mondo reale
Oggetti: rappresentano proprietà e comportamento in un unica entità
Dati e comportamento in un unico oggetto singolo
Un oggetto è definito dal suo– stato - descrive le sue caratteristiche– comportamento - quello che può fare
Esempio
Ad esempio: il modello di una moneta Una moneta può essere lanciata per consentire
una scelta casuale tra due valori: testa o croce Lo stato della moneta è la sua faccia corrente
(testa o croce) Il comportamento consiste nel fatto di poter
essere lanciata Il comportamento può modificare il suo stato
Dati: testa, crece
Stato=testa
•Lancimi-> modifica lo stato
moneta
Alcune differenze tra OO e procedurale
OOP: dati e comportamento contenuti in un oggetto singolo
Procedurale: dati e comportamento sono separati
OOP: divide il problema in oggetti separati che realizzano azioni relazionadosi o utilizzando altri oggetti
Procedurale: ad alte complessità si evidenzia un cedimento del sistema
OOP: manutenzione, riusabilità e modifiche possono essere eseguite in modo più semplice della programmazione procedurale
Esempio: conto corrente
Programmazione procedurale:– Decomposizione funzionale del problema
Divisione del problema in moduli Struttura dati (Numero correntista, Nome correntista,
Saldo Implementazione delle funzioni per operare sui dati:
– Deposito(ID, #)– Prelievo(ID, #)– CaolcoInteressi(ID)– ......
Esempio: conto corrente
Programmazione ad Oggetti– Dati e funzioni non sono entità separate– Programma: insieme di oggetti, che sono istanze
di un tipo di dato astratto
ContoCorrente
NumeroCorrentistaNomeCorrentistaSaldoNumeroOperazioni
Deposita(valore)Preleva(valore)CalcolaInteressi()IncrementaNumeroOperzazioniLeggiNumeroOperazioni()
OOP
Esempio oggetto ContoCorrente– Un particolare conto corrente è una ‘istanza’ del
tipo dati astratti– Ogni oggetto deve essere creato per essere
utilizzato Esempio:
ContoCorrente cc = new ContoCorrente();
cc.Deposito(1000);
Modelli orientato agli Oggetti Modello ad oggetti
– Il mondo viene visto come un sistema di cose
Comportamento visibile
Un oggetto
Stato interno nascosto
Oggetto = stato + comportamento + identità
Passi per la modellazione
Identificare gli oggetti Identificare il comportamento degli oggetti Identificare le relazioni tra gli oggetti Realizzare gli oggetti
Approccio orientato agli oggetti
Caratteristiche di un oggetto:– Attributi (Struttura dati)– Comportamento
Caratteristiche richiesto da un approccio orientato agli oggetti– Identità– Polimorfismo– Ereditarietà
Approccio orientato agli Oggetti
Identità– Oggetti sono distinti: ogni oggetto ha la sua
identità anche se i suoi attributi sono identici– Esempio: due mele anche se di colore e forma
identiche sono due oggetti distinti– Oggetti sono definiti tramite un linguaggio di
programmazione
Approccio orientato agli Oggetti
Polimorfismo– Ancora persto per capire tale caratteristica– “Il poliformismo, nella programmazione orientata
agli oggetti, permette diversi comportamenti da parte della stessa operazione”
Approccio orientato agli Oggetti
Ereditarietà– Creazione di una gerarchia tra gli oggetto o classe– Esistenza di una super classe, un oggetto che
contiene tutti gli altri oggetti– La superclasse fattorizza le proprietà comuni di
diverse classi– Un oggetto o classe eredita tutte le proprietà della
super classe e aggiunge altre proprietà– Normalmente le proprietà della super classe non sono
ripetute nelle sottoclassi – se ripetute, in alcuni casi, si hanno degli effetti di
Polimorfismo
Parliamo di Classi
Possiamo definire una classe per produrre oggetti specifici
Ad esempio: una classe per simulare il lancio di una moneta
Scriviamo la classe Moneta per rappresentare il modello di una moneta
Cos’e’ una classe
• Una classe contiene la dichiarazione dei dati e dei metodi
int x, y;char ch;
Dichiarazioni di datistato
Dichiarazioni di metodicomportamento
Classi e istanza
faccia 0
moneta_1
Moneta()
lancia()
dammiFaccia()
int faccia;
class MonetaMoneta
faccia 1
moneta_2
Moneta
Riassunto
Programmi per computer sono simulazioni digitali di modelli concettuali e fisici
Un oggetto è una singola istanza di una classe, che contiene la struttura e il comportamento definiti dalla classe
Spesso ci si riferisci a tali oggetti come “istanze di una classe”
Programmazione ad oggetti
Oggetti Classi Interazione tra oggetti Incapsulamento Interfaccia Accesso agli attributi
Classi Possono esistere più oggetti che hanno gli stessi attributi,
anche con valori diversi, e che dispongono degli stessi metodi. Si dice che questi oggetti appartengono alla stessa classe
Una classe specifica gli attributi, senza indicarne il valore, e i metodi che devono avere gli oggetti che appartengono alla classe
La classe quindi crea più oggetti tutti con gli stessi attributi e gli stessi metodi. Gli oggetti creati a partire da una classe vengono chiamati istanze della classe
Due istanze della stessa classe sono distinguibili solo per il valore dei loro attributi, mentre il loro comportamento (metodo) è lo stesso
Lezione 2
Classi
La struttura di una classe è la seguente:
Lezione 2
<nome classe>
<attributo1>
<attributo2>
…
<metodo1>
<metodo2>
…
Diagramma
delle classi
Classi
Esempio:
Lezione 2
Automobile
Velocità
Colore
Numero di porte
Marca
Avviati
Accelera
Fermati
Gira
Cambia marcia
Rifornisciti
INTERFACCIA E IMPLEMENTAZIONE
L'interfaccia esprime una vista astratta di un ente computazionale, nascon-dendone – l'organizzazione interna – i dettagli di funzionamento
L'implementazione esprime – la rappresentazione dello stato interno – il codice
di un ente computazionale
ASTRAZIONE
Si focalizza sul funzionamento osservabile di un ente
”Abstraction helps people to think about what they are doing”– la struttura interna di un servitore è inessenziale
agli occhi del cliente
– basta assicurare il rispetto del contratto stabilito dall’interfaccia.
INCAPSULAMENTO
Si focalizza sull’implementazione di un ente
“Encapsulation allows program changes to be reliably made with limited effort”
Astrazione e incapsulamento sono concetti complementari.
INDIPENDENZA DALLA RAPPRESENTAZIONE
Incapsulamento comporta che la rappresentazione concreta di un dato
può essere modificata senza che vi siano ripercussioni sul resto
del programma.
DAL DIRE AL FARE ...
In assenza di precisi supporti linguistici, in fase di codifica si può però compromettere il livello di astrazione
e con esso la modularità e la riusabilità della soluzione.
RAPPRESENTAZIONE & ASTRAZIONE
Attraverso i costruttori di tipo (array, struct, enum, etc.) il progettista può definire strutture dati che siano la rappresentazione concreta delle astrazioni che ha in mente.
Occorre catturare la semantica delle astrazioni di dato, cercando di impedire l’accesso diretto alla rappresentazione concreta del dato.
Java
JAVA: obiettivi di progetto del linguaggio
Nota storica: Il linguaggio JAVA (inizialmente Oak) è stato progettato in origine per programmare i microchip di elettrodomestici
REQUISITI PROGETTUALI PRINCIPALI
• familiare
• object-oriented
• robusto
• efficiente
• sicuro
• portabile
• semplice
• concorrente
• dinamico
• distribuito
JAVA ha una sintassi familiare
-I progettisti di JAVA sapevano che un nuovo linguaggio non avrebbe preso piede se non avesse avesse avuto una sintassi familiare ai programmatori professionisti, così scelsero di utilizzare quanto più possibile una sintassisimile al C++
- JAVA non è comunque la versione “per Internet” di C++
-E’ un linguaggio fondato sulle necessità e sulle esperienze di “veri” programmatori
JAVA è object-oriented
-JAVA risponde all’esigenza di realizzare sistemi software facili da modificare e manutenere
- JAVA consente alti livelli di riusabilità del codice
- JAVA fornisce un’arsenale di classi per lo sviluppo di interfacce utente e di applicazioni Internet impiegabili con relativa facilità
JAVA è robusto
-Una delle principali fonti di crash dei programmi scritti in C/C++ è l’uso scorretto dell’aritmetica dei puntatori: JAVA non fornisce tipi puntatori, né tanto meno l’aritmetica dei puntatori
Linguaggi compilati e interpretati
linguaggio compilato
Il compilatore produce un eseguibile in codice macchina. L’esecuzione sarà molto veloce ma lo stesso eseguibile non può essere usato su piattaforme diverse.
linguaggio interpretato
Il codice é indipendente dalla piattaforma, ma deve essere eseguito attraverso un interprete che in genere è molto poco efficiente.
Java ha un compilatore ed un interprete.
JAVA è efficiente
-Sebbene l’eseguibile prodotto dal compilatore JAVA sia una sequenza di comandi per un interprete, ciò rende i programmi JAVA mediamente poco più lenti di corrispondenti programmi C++. -La perdita di efficienza che ne deriva è più che accettabile per il tipo di applicazioni cui è solitamente applicato JAVA, tipicamente programmi altamente interattivi
-Altri linguaggi interpretati quali BASIC, Tcl, PERL, presentano livelli di inefficienza tali da limitarne decisamente la possibilità di utilizzo
JAVA è sicuro
-Il rischio di infezione virale o di introduzione di “cavalli di Troia” nell’eseguire sul proprio computer programmi convenzionali di provenienza incerta è molto alto. Ciò rendeva la pratica di “scaricarsi” programmi eseguibili da Internet qualcosa di poco sicuro e da evitare -JAVA offre un ambiente di esecuzione sicuro confinando il programma scaricato da Internet in un “firewall” da cui non è possibile accedere ad altre parti del computer
JAVA è portabile (indipendente dalla piattaforma)
-Programmi scritti in linguaggi convenzionali quali il C e il C++ sono, almeno in teoria, portabili da una piattaforma all’altra, a patto di ricompilarli per la nuova piattaforma
-Dei programmi scaricabili da Internet si ha a disposizione spesso solo l’eseguibile, specifico per ciascun tipo di CPU se si tratta di programmi scritti in C/C++
-Se pure fosse disponibile il sorgente del programma, saremmo costretti a ricompilarlo prima di poterlo eseguire - JAVA: la magia del Bytecode
JAVA è portabile: bytecode e macchina virtuale
Codice sorgente
CompilatoreCodice oggetto
CPUCompilatore convenzionale
Codice sorgente
Compilatore Bytecode
Macchina virtualeper computer A
Compilatore JAVA
Macchina virtualeper computer B
Macchina virtualeper computer C
JAVA è semplice
-JAVA è facile da imparare e da impiegare in maniera produttiva, soprattutto se si conosce la filosofia di fondo della programmazione a oggetti e/o il linguaggio C++
-Le caratteristiche più complesse di C++ sono state escluse da JAVA, oppure realizzate in maniera più semplice
-JAVA non comprende caratteristiche insolite o sorprendenti: esiste sempre un numero ridotto di modi ben chiari e definiti per eseguire un determinato compito
-A differenza di altri linguaggi sovraccarichi di caratteristiche (esempio, ADA), JAVA ha un numero minimo di caratteristiche di base, estensibili se necessario con l’uso di librerie
JAVA è concorrente
-JAVA fornisce gli strumenti per gestire flussi di controllo concorrenti: i Thread e i meccanismi di sincronizzazione
-L’approccio facile alla concorrenza offerto da JAVA permette di concentrarsi sul comportamento specifico del programma, piuttosto che sul come realizzare e gestire il mutlitasking
JAVA è dinamico
- I programmi JAVA gestiscono estensivamente informazioni di tipo run-time per l’accesso agli oggetti durante l’esecuzione (es. binding dinamico)
JAVA è distribuito
- JAVA gestisce i protocolli TCP/IP: accedere ad una risorsa tramite un URL è del tutto analogo all’accedere a un file
- Invio di messaggi remoti: programmazione client/server
Programmazione in Java
Applicazione: programma eseguito dal sistema operativo
Applet: applicazione, allegata ad una pagina ipertestuale HTML ed eseguita dal visualizzatore di pagina (browser)
Servlet: applicazioni eseguita sul lato server in seguito ad una specifica richiesta
La classe
Unità fondamentale della programmazione orientata agli oggetti
Una classe è costituita da almeno un nome, che la identifica in modo univoco, e una coppia di parentesi graffe { } che dovranno contenere il corpo della classe (dichiarazioni e istruzioni)
I metodi
Le istruzioni devono essere contenute in particolari moduli detti metodi
un metodo ha una struttura simile a quella della classe: è definito tramite un nome e una coppia di parentesi graffe (blocco)
I nomi dei metodi e delle classi possono essere preceduti da altri termini (es. public, static, ecc.)
Applicazioni
Un’applicazione deve sempre contenere il metodo main (principale) entro al quale inserire le istruzioni dalle quali avrà inizio l'esecuzione del programma. Ad esempio:
public class Vuota { public static void main(String args[ ]) { // Inserire le istruzioni del programma }
}
Commenti
/*Commento di più righeCommento di più righeCommento di più righe
*/
// Commento di una riga
/** Commento di documentazione (Javadoc)
Identificatori
Designano gli elementi della programmazione Possono essere composti da lettere, cifre, il carattere
_ e il carattere $ Non possono iniziare con una cifra Simboli maiuscoli e minuscoli sono trattati come
caratteri diversi (case sensitive) Alcuni identificatori hanno un significato prestabilito:
parole chiave e riservate; questi identificatori non possono essere ridefiniti
Parole chiave e riservate
abstractbooleanbreakbytecasecatchcharclassconst2
continuedefaultdodouble
elseextendsfalse1
finalfinallyfloatforgoto2
ifimplementsimportinstanceofint
interfacelongnativenewnull1
packageprivateprotectedpublicreturnshortstaticstrictfp
superswitchsynchronizedthisthrowthrowstransienttrue1
tryvoidvolatilewhile
1. parole riservate; 2. parole al momento non utilizzate
Tipi di dati (primitivi)
Interi
bit tipo
8 (±) byte
16 (±) short
32 (±) int
64 (±) long
Virgola mobile (reali)
bit tipo
32 float
64 double
Tipo
Caratterechar (*)(16 bit)
Logico boolean
(*) tipo char unicode a 16 bit compatibile con i numeri interi
Dichiarazioni
Esempi
Variabili
int n;float x;char c;boolean enunciato;int v[] = new int[3];String parola;
Costanti final float IVA = 0,20;
Librerie import awt.*;
Operatori aritmetici
Operatore Simbolo
Addizione +
Sottrazione -
Moltiplicazione *
Divisione /
Modulo %
Incremento ++n; n++
Decremento --n; n--
Operatori logici
Operatore Simbolo
Negazione !
Congiunzione &&
Disgiunzione
Inclusiva||
Disgiunzione
esclusiva^
Operatori bitwise
Operatore Simbolo
Congiunzione &
Disgiunzione Inclusiva |
Disgiunzione esclusiva ^
Complemento ~
Operano su numeri interi bit per bit
Operatori bitwise (Esempi)
110&
010
010110
|010
110
110^
010
100
~101
=010
Operatori di scorrimento (shifting)
Operatore Simbolo
Scorrimento a sinistra
con riempimento di zeri a destra<<
Scorrimento a destra
con estensione del bit di segno da sinistra>>
Scorrimento a destra con riempimento di zeri a sinistra
>>>
Operano su numeri interi bit per bit
Operatori diassegnazione e relazione
Operatore Simbolo
Di assegnazione =
Uguale ==
Diverso !=
Maggiore >
Minore <
Non maggiore <=
Non minore >=
Forme abbreviate(esempi con operatori aritmetci)
Operazione Forma abbreviata equivale a
Addizione a += b a = a + b
Sottrazione a -= b a = a - b
Moltiplicazione a *= b a = a * b
Divisione a /= b a = a / b
Possono essere utilizzate anche con altri operatori binari
Caratteri speciali(Sequenze escape)
Carattere Descrizione
\n A capo (new line)
\t Tabulazione
\b Cancella a sinistra (backspace)
\r Inizio riga (carriage return)
\f Avanzamento pagina (form feed)
\\ Barra inversa
\” Virgolette
\’ Apice
Conversioni di tipo
Implicita (automatica) esempio
A un tipo più ‘capiente’ viene assegnatoun tipo meno ‘capiente’double float long int char short byte
int i = 24;
long n = i;
Esplicita (casting) esempio
Si indica di fronte alla variabile il nuovo tipotra parentesi: (nuovo_tipo) variabile;
long n = 24;
int i = (int) n;
Applicazioni: classe “Hello”
public class Hello{ // Una classe per cominciare a lavorare con Java
public static void main(String[] args) { // Mostra la stringa “Ciao, come stai?”
System.out.println("Ciao, come stai?");}
}
Applicazioni: classe “Somma”
public class Somma{ // Calcola la somma di 4 e 5
public static void main(String[] args){
// dichiarazione variabili e assegnazione valoriint a = 4;int b = 5;// Mostra il risultato della sommaSystem.out.println(“a+b = “ + (a+b));
}}
Selezione
if if (condizione) istruzione;
if
elseif (condizione) istruzione;
else istruzione;
if
else(blocco)
if (condizione)
{ istruzione; istruzione; …; }
else
{istruzione; istruzione; …; }
Selezione multipla
switch
switch (i) // i variabile byte o short o int o char
{
case 1: istruzione;
break;
case 2: { istruz; istruz; …; }
break;
case 3: { istruz; istruz; …; }
break;
default:
{ istruz; istruz; …; }
}
Ciclo enumerativo
for
for (int i=start; i<=stop; i++)
{
istruzione; istruzione; …;
}
for (int i=start; i<=stop; i--)
{
istruzione; istruzione; …;
}
Nota: si possono usare le istruzioni break o continue per uscire dal ciclo o riprenderlo
Ciclo condizionato
do
while
do
{
istruzione; istruzione; …;
} while (condizione);
while (condizione)
{
istruzione; istruzione; …;
}
Inizializzazione degli oggetti
Costruttore di default– E’ l’inizializzazione eseguita automaticamente se
non sono stati definiti altri costruttori
Il costruttore di una sottoclasse può chiamare quello della superclasse tramite il metodo super– La chiamata a super deve essere la prima
istruzione del costruttore
Costruttori (1)class MezzoDiTrasporto { int velocitaMassima; int numeroPasseggeri; MezzoDiTrasporto (int velocitaMassima, int numeroPasseggeri) { this.velocitaMassima = velocitaMassima; this.numeroPasseggeri = numeroPasseggeri; }}
class Autoveicolo extends MezzoDiTrasporto { String tipoDiMotore; int potenza; Autoveicolo (int velocitaMassima, int numeroPasseggeri, int
potenza) { super(velocitaMassima, numeroPasseggeri); this.potenza = potenza; }}
class Furgone extends Autoveicolo { int portata; Furgone (int velocitaMassima, int potenza, int portata) { super (velocitaMassima, 2, potenza); this.portata = portata; }}
this.potenza = potenza;
this.portata = portata;
this.velocitaMassima = velocitaMassima; this.numeroPasseggeri = numeroPasseggeri;
Costruttori (2)
Nell’ordine vengono eseguiti:– costruttore delle classi padre– inizializzazione campi locali– esecuzione resto del codice del costruttore
Esempio:class Furgone extends Autoveicolo { int portata; Motore motore = new Motore(); Furgone (int velMax, int pot, int port) { super (velMax, 2, pot); portata = port; }}
1super (velMax, 2, pot);
2Motore motore = new Motore();
3portata = port;
Specificatori di accesso
Organizzare le classi in librerie, ma quali metodi e attributi di una classe si possono usare?
Definire per ogni membro della classe quale visibilità offre ai possibili clienti– può essere specificato sia per metodi che per
attributi Possibilità di accesso:
– (friendly)– public– protected – private
(friendly)
Accesso di default, non ha una clausola particolare tutte le classi all’interno dello stesso package hanno
accesso ai membri friendly (package access)– Default package (friendly):
classi che non appartengono a nessun package sono nella stessa directory
La dichiarazione di quell’attributo o metodo lo rende accessibile a tutti
(relazione fra classi: package)
Specificatori di accessoSpecificatori di accesso
publicpublic
Nessuno può accedere a quel metodo o attributo eccetto la classe stessa all’interno dei propri metodi
– lavoro cooperativo: ognuno può modificare quanto da lui dichiarato privato senza alcun impatto sul codice degli altri sviluppatori
– utile soprattutto per il multithreading
Garantire accesso a attributi e metodi per le sole classi derivate
(relazione fra classi: ereditarietà))
Specificatori di accesso
privateprivate
protected
Visibilità in Java
PackageClient
Client
metodoPublicmetodoFriendlymetodoProtectedmetodoPrivate
Client
Server
package mialibreria.utilita;
public class StampaMessaggio { StampaMessaggio() {
System.out.println("Costruttore classe StampaMessaggio");
} void visualizzaMessaggio(String msg) { System.out.println("*StampaMessaggio:"+msg);}
public static void main (String[] arg) {StampaMessaggio sm = new StampaMessaggio();sm.visualizzaMessaggio(arg[0]);
}}
Dichiaro una classe senza specificare un qualificatore per il costruttore
– Posso istanziare la classe solo all’interno del package ‘utilita’
Esempio (1)Esempio (1)
Esempio precedente: public class StampaMessaggio:– attualmente non può esser utilizzata da nessun client esterno al
package. Non è stata specificato nulla: friendly
import mialibreria.utilita.*;
class Registro { public static void main (String[] arg) {
StampaMessaggio sm = new StampaMessaggio();sm.visualizzaMessaggio(arg[0]);
}}
No constructor matching StampaMessaggio() found in class mialibreria.utilita.StampaMessaggio.
Esempio (2)
package mialibreria.utilita;
public class StampaMessaggio { public StampaMessaggio() {
System.out.println("Costruttore classe StampaMessaggio");} public void visualizzaMessaggio(String msg) { System.out.println("*StampaMessaggio:"+msg);}
public static void main (String[] arg) {StampaMessaggio sm = new StampaMessaggio();sm.visualizzaMessaggio(arg[0]);
}}
Soluzioni:– dichiarare la classe registro come appartenente al package: NO– dichiarare public il costruttore e il metodo della classe di libreria perchè sono funzioni che
quella classe offre ai suoi clienti
Esempio (3)Esempio (3)
Riassumendo: come consentire l’accesso ad un attributo di una classe?
1) Dichiararlo publicpermette l’accesso a qualsiasi altra classe (client)
2) Non specificare clausole (friendly)permette l’accesso da qualsiasi altra classe appartenente allo stesso package
3) Dichiararlo protectedconsente l’accesso a tutte le sottoclassi come se fosse un membro public
4) Dichiararlo private e fornire appositi metodi su cui effettuare controlli di accesso (opportune politiche)
setValue() - getValue()
Specificatori di accessoSpecificatori di accesso
Riutilizzo del codice
Copia e incolla, ma:– I sorgenti non sono sempre disponibili– E’ necessario ripetere testing e debugging
Composizione– Le nuove classi contengono ed utilizzano le
funzionalità di quelle preesistenti
Ereditarietà– Estensione delle vecchie classi con nuove
funzionalità
Esempio di Composizione
Autoveicolo composto da:– volante– motore, che a sua volta
è composto da: carburatore pistoni ...
– ...
class Carburatore {...}
class Pistone {...}
class Motore { Carburatore
carburatore; Pistone[] pistoni; ...}
class Volante {...}
class Autoveicolo { Motore motore; Volante volante; String modello; ...}
Esempio di Ereditarietà Mezzo di trasporto
– ha velocità massima– numero di passeggeri– ....
Autoveicolo– è un mezzo di trasporto– tipo di motore– potenza– ....
Furgone– è un autoveicolo– portata– ....
class MezzoDiTrasporto { int velocitaMassima; int numeroPasseggeri;}
class Autoveicolo extends MezzoDiTrasporto {
String tipoDiMotore; int potenza;}
class Furgone extends Autoveicolo { int portata; String datiTecnici() { return " portata = " + portata + " potenza = " + potenza + " velocità = " + velocitaMassima; }}
Ereditarietà vs composizione
Quando è meglio usare la Composizione ?Quando è meglio usare l’Ereditarietà ?
Esempio:
Rettangolo
colorebasealtezza
getColore()getBase()getAltezza()
Cerchio
coloreraggio
getColore()getRaggio()
Esempio (1)
import java.lang.String;
class Figura{ private String colore; Figura(String col) { colore = col; } String getColore() { return colore; }}
class Rettangolo { private double altezza; private double base; private Figura figura; Rettangolo (String col, double alt,
double bas) {figura = new Figura(col);altezza = alt;base = bas;
} String getColore() { return figura.getColore(); }}
class Cerchio { private double raggio; private Figura figuraCer; Cerchio (String col, double rag) { figuraCer = new Figura(col); raggio = rag; } String getColore() { return figuraCer.getColore(); }}
Case sensitive
Rettangolo
basealtezza
getBase()getAltezza()
Cerchio
raggio
getRaggio()
Figura
Colore
getColore()
Ereditarietà e riuso del codice
import java.lang.String;
class Figura{ private String colore; Figura(String col) { colore = col; } String getColore() { return colore; }}
class Rettangolo extends Figura { private double altezza; private double base; Rettangolo (String col, double alt,
double bas) {super(col);altezza = alt;base = bas;
} double getArea() { return altezza * base; }}
class Cerchio extends Figura { private double raggio; Cerchio (String col, double rag) { super(col); raggio = rag; } double getArea() { return raggio * raggio * 3.14; }}
Rettangolo
basealtezza
getBase()getAltezza()
Cerchio
raggio
getRaggio()
Figura
coloregetColore()
Esempio (2)
Il problema dell’area
Una figura ha sempre un’area, che non può essere calcolata a priori
Un rettangolo ha un suo modo peculiare per calcolare l’area
Un cerchio ha un altro modo per calcolare l’area
Rettangolo
basealtezza
getArea()
Cerchio
raggio
getArea()
Figura
Colore
getColore()getArea()
Ereditarietà e binding dinamico
Esempio (3)
import java.lang.String;
class Figura{ private String colore; Figura(String col) { colore = col; } String mioColore() { return colore; } double getArea() { return 0; }}
class Rettangolo extends Figura { private double altezza; private double base; Rettangolo (String col, double alt,
double bas) {super(col);altezza = alt;base = bas;
} double getArea() { return altezza * base; }}
class Cerchio extends Figura { private double raggio; Cerchio (String col, double rag) { super(col); raggio = rag; } double getArea() { return raggio * raggio * 3.14; }}
Metodi Astratti
In Figura è presente un metodo getArea, impossibile da concretizzare ignorando il tipo di figura
Si realizza il metodo dichiarandolo abstract
Tutte le sottoclassi devono fornire un’implementazione del metodo per non essere a loro volta astratte
import java.lang.String;
abstract class Figura { private String colore; Figura(String col) { colore = col; } String getColore() { return colore; } abstract double getArea();}
class Rettangolo extends Figura { private double altezza; private double base; Rettangolo (String col, double alt, double bas) {
super(col);altezza = alt;base = bas;
} double getArea() { return altezza * base; }}
Esempio (6)
class Inutile { public static void main(String args[ ]) { Rettangolo rettRosso = new Rettangolo("Rosso", 10, 20); Quadrato quadGiallo = new Quadrato("Giallo", 40); Quadrato quadVerde = new Quadrato("Verde", 15);
// rettRosso = quadGiallo; // ok rettRosso diventa un quadrato
// quadGiallo = rettRosso; // errore in compilazione
// quadGiallo = (Quadrato)rettRosso; // invalid cast a runtime
// rettRosso = quadVerde; // quadGiallo = (Quadrato)rettRosso; // ora va bene
System.out.println(" ret rosso = " + rettRosso.getArea() ); System.out.println(" ret giallo = " +
quadGiallo.getArea() ); }}
import java.lang.String;
class Figura{ ... }
class Rettangolo extends Figura { ... }
class Quadrato extends Rettangolo { ... }
class Cerchio extends Figura
{ ... }
Immagine = array di Figure
Polimorfismo: esempio
Immagine = insieme di
figure
Immagine = contenitore
di figure in grado di
stamparsi
Rettangolo............
Quadrato
Figura............
Cerchio............
Esempio (7)
import java.lang.String;
abstract class Figura{ private String colore; Figura(String col) { colore = col; } String getColore() { return colore; } abstract void stampati();}
class Rettangolo extends Figura { private double altezza; private double base; Rettangolo (String col, double alt,
double bas) {super(col);altezza = alt;base = bas;
} void stampati() { System.out.println(" sono un rettangolo"
+ getColore()); }}
class Cerchio extends Figura { private double raggio; Cerchio (String col, double rag) { super(col); raggio = rag; } void stampati() { System.out.println(" sono un cerchio " +
getColore()); }} class Immagine { Figura figure[] = new Figura[10]; int contatore = 0; void addFigura(Figura newFig) { figure[contatore++] = newFig; } void stampa() { for (int i = 0; i < contatore; i++) figure[i].stampati(); } public static void main ( String args[ ]) { Immagine immagine = new Immagine(); immagine.addFigura(new Rettangolo("verde",
10,20)); immagine.addFigura(new Cerchio("rosso", 15)); immagine.stampa(); }}
Vantaggi del polimorfismo
Aggiunta della classe Quadrato In Immagine è stato utilizzato il polimorfismo
(metodo generico addFigura()), quindi non bisogna cambiare niente
Con metodi diversi (addRettangolo(), addCerchio(), …) l’aggiunta della classe quadrato implica una modifica alla classe Immagine (aggiunta del metodo addQuadrato())
class Quadrato extends Rettangolo { Quadrato (String col, double lato) {
super(col, lato, lato); } void stampati() { System.out.println(" sono un quadrato " +
getColore()); }}
Ereditarietà multipla
Pianoforte
Oggetto di legnoStrumento musicale
Una classe può avere più padri di pari livello In Java non è consentita, per la fragilità del
meccanismo Realizzata attraverso il concetto di interfaccia.
Interfacce
Un’interfaccia è una collezione di metodi privi di implementazione e costanti.
Si usano per definire l’insieme di metodi che devono essere concretizzati dalle classi che implementano l’interfaccia
Se una classe implementa un’interfaccia, il compilatore verifica che esistano definizioni per tutti i relativi metodi
class interface
extends implements
Interfacce: esempio (8)
interface Strumento {String descrizione = "azioni di uno strumento musicale generico";
// valore implicitamente static e final
void suona() ; // notare l’assenza della implementazione
String nome() ;}
class flauto implements Strumentoclass flauto implements Strumento {public void suona() {
System.out.println(" fiuuu");}public String nome() {
return "flauto";}public String descrizione() {
return "sono un flauto di marca";}
}
Esempio di interfacce
interface Strumento{
suona ( );
nome ( );}
interface InVendita {
prezzo ( );
disponibile ( );}
Pianoforte In Vendita
Implements
Implements
Oggetto di legno
Extends
Interfacce
Una classe può estendere una sola classe ma può implementare un numero illimitato di interfacce
class PianoforteInVendita extends OggettoDiLegno implements Strumento, InVendita { ...}
Un pianoforte in vendita è un oggetto di legno e uno strumento musicale è un bene in vendita
Ereditarietà multipla e Java
Impedita per classi– 1 solo "extends"
Permessa per interfacce– numero non limitato di "implements"
Interfacce come classi astratte pure, i cui metodi sono tutti vuoti– comportamento sempre univoco e "pulito" (più o
meno)
Il metodo toString()
Restituisce la rappresentazione testuale di un oggetto
E’ definito in Object e quindi presente in ogni oggetto E’ chiamato automaticamente o esplicitamente nelle
operazioni con le stringhe
– utilizzando il codice di default
– utilizzando il metodo ridefinito Esempi di utilizzo:
System.out.println("esempio: "+(new Integer(3)));
System.out.println("esempio: "+(new Cerchio("red",12)));
Esempio (4)
class Inutile {
public static void main(String args[ ]) {
Rettangolo rettRosso =
new Rettangolo("Rosso", 10, 20);
Quadrato quadGiallo = new Quadrato("Giallo",
40);
Cerchio cerchioBlu = new Cerchio("blu", 15);
System.out.println("che tipo sei? " + rettRosso);
System.out.println("che tipo sei? " + quadGiallo);
System.out.println("che tipo sei? " +
cerchioBlu.toString());
}
}
Class Figura { public String toString() { return "sono una figura"; } ...}
class Rettangolo extends Figura { public String toString() { return "sono una figura con angoli"; } ...}
class Quadrato extends Rettangolo { ...}
class Cerchio extends Figura { public String toString() { return "sono una figura senza
angoli"; } ... }
Esempio (5)
class Inutile {
public static void main(String args[ ]) {
Figura figura = new Figura("Verde");
Cerchio cerchioBlu = new Cerchio("blu", 15);
System.out.println("che tipo sei ? " + figura.toString() );
figura = cerchioBlu;
System.out.println("che tipo sei ? " + figura.toString() );
}
}
Class Figura { public String toString() { return "sono una figura"; } ...}
class Rettangolo extends Figura { public String toString() { return "sono una figura con angoli"; } ...}
class Quadrato extends Rettangolo { ...}
class Cerchio extends Figura { public String toString() { return "sono una figura senza angoli"; } ... }
overloadingL'overloading consente di definire in una
stessa classe più metodi aventi lo stesso nome
(ridondanza), ma che differiscano nella
firma, cioè nella sequenza dei tipi dei parametri
formali. È il compilatore che determina quale
dei metodi verrà invocato, in base al numero e
al tipo dei parametri attuali.
Overriding L'overriding, invece, consente di ridefinire un
metodo in una sottoclasse: il metodo originale
e quello che lo ridefinisce hanno necessariamente la stessa firma, e solo a tempo di esecuzione si determina quale dei due deve essere eseguito (polimorfismo).
Late Binding - binding dinamico Il polimorfismo è particolarmente utile quando la
versione del metodo da eseguire viene scelta sulla base del tipo di oggetto effettivamente contenuto in una variabile a runtime (invece che al momento della compilazione). Questa funzionalità è detta binding dinamico (o late-binding), e richiede un grosso sforzo di supporto da parte della libreria runtime del linguaggio.
Se ho una variabile di tipo A, e il tipo A ha due sottotipi (sottoclassi) B e C, che ridefiniscono entrambe il metodo m(), l'oggetto contenuto nella variabile potrà essere di tipo A, B o C, e quando sulla variabile viene invocato il metodo m() viene eseguita la versione appropriata per il tipo di oggetto contenuto nella variabile in quel momento.
Esercizio - Dadi
Disegnare e scrivere un’applicazione che simuli una partita a dadi tra due giocatori.
Ogni giocatore lancia il proprio dado, il quale rotola e espone una faccia (valori tra 1 e 6).
Si vogliono visualizzare N tiri di dado sulla console.
Input / Output
Spesso un programma deve acquisire
dati da una sorgente esterna o inviare
informazioni a una destinazione esterna.
L’informazione può essere di ogni tipo: caratteri,
immagini,
suoni,
oggetti.
Input / OutputStream di Input / Output
Per acquisire dati, un programma apre uno stream (o flusso)associato alla sorgente di informazione (file, socket, memoria, ecc.) e legge l’informazione sequenzialmente da esso.
In modo analogo, un programma puo’ inviare verso una destinazione esterna dei dati aprendo uno stream associato alla destinazione e scrivendovi in modo sequenziale i dati.
Indipendentemente dall’origine e dalla destinazione dei dati e dal loro tipo, gli algoritmi per leggere e scrivere sequenzialmente dei dati sono gli stessi.
Stream di Input / Output
Input / Output
Lettura ScritturaApertura dello stream
Finché e’ presente informazione
lettura dell’informazione
Chiusura dello stream
Apertura dello stream
Finché e’ presente informazione
scrittura dell’informazione
Chiusura dello stream
Tipi di Stream Le classi di gestione degli stream sono di due tipi in base
ai dati su cui operano (caratteri/byte).
– Stream di Caratteri: classi Reader e Writer– Stream di Byte: classi InputStream e OutputStream (di
solito usati per leggere file di immagini e suoni).
Esistono varie sottoclassi che consentono la lettura/scrittura su file: – FileReader e FileWriter (file di testo) – FileInputStream e FileOutputStream (file binari).
Classi FileReader e FileInputStream
Lettura Per leggere caratteri da un file si crea un oggetto di tipo FileReader.
FileReader(String fileName)
Esempio: FileReader reader = new FileReader(“input.txt”);
Si utilizza il metodo int read() che legge un carattere per volta e restituisce un valore di tipo int.
Tale valore corrisponde al codice del carattere letto oppure –1 se non ci sono più dati da leggere.
Scrittura di dati su file Scrittura
Si utilizza analogamente la classe FileWriter per scrivere in un file sequenze di caratteri.
FileWriter writer = new FileWriter (“output.txt”);
Si utilizza il metodo void write(int c) che scrive un carattere per volta.
Tale valore corrisponde al codice del carattere da scrivere nel file.
Chiusura di un file
Dopo avere letto/scritto tutti i dati nel file, questo deve essere chiuso con il metodo void close().
Copia di un file
1. import java.io.*;2. 3. public class CopyChars {4. public static void main(String[] args)5. throws IOException {6. FileReader in = new FileReader(args[0]);7. FileWriter out = new FileWriter(args[1]);8. int c;9. 10. while ((c = in.read()) != -1)11. out.write(c);12. 13. in.close();14. out.close();15. }16. }
Classe BufferedReader
Un BufferedReader permette di gestire un flusso tramite un buffer.– I dati vengono letti a blocchi dal flusso e
memorizzati in un buffer (area di memoria).– Quando viene richiesto un nuovo dato prima si
verifica la sua disponibilità nel buffer e, se non disponibile in memoria, si legge un nuovo blocco.
Metodi disponibili in aggiunta a quelli di Reader
String readLine()Legge una riga e la restituisce sotto forma di stringa
Costruttori disponibili
BufferedReader(Reader in)Crea un oggetto BufferedReader a partire da un oggetto Reader
Lettura bufferizzata FileReader file = new FileReader (“nome-file”);
BufferedReader in = new BufferedReader (file);
oppure
BufferedReader in = new BufferedReader (new FileReader (“nome-file”));
Lettura di una riga: in.readLine();
Lettura
1. import java.io.*;2. 3. public class testLettura {4. public static void main(String[] args)5. throws IOException {6. FileReader file = new FileReader(args[0]);7. BufferedReader in = new BufferedReader(file); 8. String line; 9. while ((line = in.readLine()) != null)10. System.out.println(line);11. 12. in.close();13. }14. }
Classe PrintWriter
La classe PrintWriter mette a disposizione i metodi void print() e void println() utilizzabili con qualunque tipo di parametro (stringa, intero, reale, ecc.).
Si può creare un nuovo oggetto PrintWriter a partire da un Writer, in particolare da un FileWriter.
PrintWriter f = new PrintWriter ( new FileWriter (“nome-file”) );
Copia file
1. import java.io.*;2. 3. public class testCopia {4. public static void main(String[] args)5. throws IOException {6. FileReader file = new FileReader(args[0]);7. BufferedReader in = new BufferedReader(file); 8. String line; 9. PrintWriter out = new PrintWriter (new
FileWriter(args[1]));10. while ((line = in.readLine()) != null)11. out.println(line);12. 13. in.close(); 14. out.close();15. }16. }
Classe StringTokenizer La classe StringTokenizer e’ definita nel package
java.util.
Un oggetto StringTokenizer separa una stringa in sottostringhe dette token.
Per default, il tokenizer separa la stringa ad ogni spazio.
Il costruttore StringTokenizer richiede come parametro la stringa da separare.
Ciascuna chiamata al metodo nextToken restituisce il token successivo.
Esempio:
1 23 4 -56 65 21 32 15 0 -3
Classe StringTokenizer The string tokenizer class allows an application to break a string
into tokens. Constructor Summary
StringTokenizer(String str) Constructs a string tokenizer for the specified string.
StringTokenizer(String str, String delim) Constructs a string tokenizer for the specified string.
Method Summary int countTokens()
Calculates the number of times that this tokenizer's nextToken method can be called before it generates an exception.
boolean hasMoreTokens() Tests if there are more tokens available from this tokenizer's string.
String nextToken() Returns the next token from this string tokenizer.
Lettura token
1. import java.io.*;2. import java.util.*;
3. public class testLetturaToken {4. public static void main(String[] args)5. throws IOException {6. if(args.length>0){7. FileReader file = new FileReader(args[0]);8. BufferedReader in = new BufferedReader(file);9. String line;10. while ((line = in.readLine()) != null) {11. StringTokenizer st = new StringTokenizer(line);12. while(st.hasMoreTokens())13. System.out.println(st.nextToken());14. }15. in.close();16. }17. }18. }
Esempio line:
– 1 23 4 -56 65 21 32 15 0 -3
output:– 1– 23– 4– -56– 65– 21– 32– 15– 0– -3
Input da tastiera Lo standard input di un computer è visto attraverso l’oggetto predefinito
System.in Questo oggetto mette a disposizione un numero limitato di operazioni Esistono delle classi predefinite che a partire da questo oggetto creano nuovi
oggetti con maggiori funzionalità La classe InputStreamReader
Un InputStreamReader converte una sequenza di byte in una sequenza di caratteri in accordo con uno specifico sistema di codifica.
• La classe BufferedReader • Un BufferedReader legge una sequenza di caratteri, la memorizza in un buffer in
modo da fornire funzioni per la lettura di intere linee.
1. InputStreamReader reader = new InputStreamReader(System.in);
2. BufferedReader console = new BufferedReader(reader);
• Dopo queste operazioni posso utilizzare l’oggetto console e il metodo readLine() in grado di restituirmi una linea da tastiera (tutti i caratteri immessi fino alla pressione di un fine linea) sotto forma di stringa.
• String line = console.readLine();
Esercitazione – Il Giornale
Realizzare Diagramma delle Classi, Diagramma di sequenza e Implementazione relativi alle seguenti specifiche:
Si vuole realizzare un’applicazione che permetta di stampare a video la prima pagina di un giornale.
Tale pagina è costituita da tre sezioni: Alto Basso e Centro.
L’applicazione deve leggere il testo di ogni sezione in un file di testo fatto in questo modo:
Titolo: il titolo dell’ articolo
Sottotitolo: il sottotitolo
Corpo: Il corpo….
(I file di testo avreanno questi nomi: “Alto.txt”, “Basso.txt”, “Centro.txt”)
Si vuole visualizzare a video una stampa del giornale
Le classi del JDK
Contenitori Collection Set List Iterator ListIterator
Gestione tempo (Date) GregorianCalendar
L’interfaccia Collection
Collection
add(arg0 : Object) : booleanaddAll(arg0 : Collection) : booleanclear() : voidcontains(arg0 : Object) : booleancontainsAll(arg0 : Collection) : booleanequals(arg0 : Object) : booleanhashCode() : intisEmpty() : booleaniterator() : Iteratorremove(arg0 : Object) : booleanremoveAll(arg0 : Collection) : booleanretainAll(arg0 : Collection) : booleansize() : inttoArray() : Object[]toArray(arg0 : Object[]) : Object[]
(from util)
<<Interface>>
Metodi principali:– add(): aggiunge l’oggetto
specificato alla Collection– contains(): verifica la presenza
dell’oggetto specificato– isEmpty(): verifica se l’insieme
è vuoto o no– remove(): elimina l’oggetto
specificato dall’insieme– iterator(): restituisce un oggetto
Iterator per scandire gli elementi (sostituisce elements() del Vector)
L’interfaccia Set
Set
add(arg0 : Object) : booleanaddAll(arg0 : Collection) : booleanclear() : voidcontains(arg0 : Object) : booleancontainsAll(arg0 : Collection) : booleanequals(arg0 : Object) : booleanhashCode() : intisEmpty() : booleaniterator() : Iteratorremove(arg0 : Object) : booleanremoveAll(arg0 : Collection) : booleanretainAll(arg0 : Collection) : booleansize() : inttoArray() : Object[]toArray(arg0 : Object[]) : Object[]
(from util)
<<Interface>>
Collection(from util)
<<Interface>>
Le funzionalità offerte coincidono con quelle offerte dall’interfaccia Collection
Le differenze sono di tipo semantico:– questa struttura non
consente l’ordinamento degli elementi
– non è prevista la presenza di duplicati
L’interfaccia List
List
add(arg0 : int, arg1 : Object) : voidadd(arg0 : Object) : booleanaddAll(arg0 : int, arg1 : Collection) : booleanaddAll(arg0 : Collection) : booleanclear() : voidcontains(arg0 : Object) : booleancontainsAll(arg0 : Collection) : booleanequals(arg0 : Object) : booleanget(arg0 : int) : ObjecthashCode() : intindexOf(arg0 : Object) : intisEmpty() : booleaniterator() : IteratorlastIndexOf(arg0 : Object) : intlistIterator() : ListIteratorlistIterator(arg0 : int) : ListIteratorremove(arg0 : int) : Objectremove(arg0 : Object) : booleanremoveAll(arg0 : Collection) : booleanretainAll(arg0 : Collection) : booleanset(arg0 : int, arg1 : Object) : Objectsize() : intsubList(arg0 : int, arg1 : int) : ListtoArray() : Object[]toArray(arg0 : Object[]) : Object[]
(from util)
<<Interface>>
Collection(from util)
<<Interface>>
Realizza un insieme ordinato (sequenza) di elementi– l’ordinamento è esplicitato dalla modalità di
inserimento degli oggetti– permette anche l’inserimento di duplicati
Metodi principali:– get(): elemento nella posizione specificata– lastIndexOf(): posizione dell’elemento
specificato– listIterator(): dà accesso ad un Iterator
speciale in grado di usare l’ordinamento– set(): inserisce un elemento alla posizione
specificata– subList(): restituisce la sottolista specificata
L’interfaccia Iterator
Iterator
hasNext() : booleannext() : Objectremove() : void
(f rom util)
<<Interface>>
Sostituisce l’interfaccia Enumeration del JDK 1.1
Metodi:– hasNext(): verifica se ci sono
altri elementi sostituisce hasMoreElements() di
Enumeration– next(): prossimo elemento
nell’elenco sostituisce nextElement() di
Enumeration– remove(): elimina l’elemento
corrente dall’elenco metodo non presente in
Enumeration (read-only)
L’interfaccia ListIterator
ListIterator
add(arg0 : Object) : voidhasNext() : booleanhasPrevious() : booleannext() : ObjectnextIndex() : intprevious() : ObjectpreviousIndex() : intremove() : voidset(arg0 : Object) : void
(from util )
<<Interface>>
Iterator(from util )
<<Interface>> Permette di sfruttare l’ordinamento degli
oggetti– è prodotta a partire da una List
(sequenziale) Metodi aggiuntivi:
– add(), remove(): aggiunge/rimuove un elemento alla/dalla struttura
– hasPrevious(): verifica se c’è un elemento precedente rispetto a quello attuale
– previous(): elemeno precedente rispetto a quello attuale
– set(): sostituisce l’elemento attuale– nextIndex(), previousIndex(): restituisce
la posizione in cui ci si trova nella struttura
Un esempio con List ed Iterator
import java.util.*;public class SimpleCollection2 {public static void main(String[] args) {
List l = new ArrayList();for(int i = 0; i < 10; i++)
l.add(Integer.toString(i));ListIterator listIt = l.listIterator();while(listIt.hasNext()) {
System.out.println( “Elemento in posizione: “ + listIt.nextIndex() );
System.out.println(listIt.next());}
}}
Eccezioni
L’istruzione try/catch
La propagazione dell’eccezioni
Intercettare e gestire eccezioni
Eccezioni in breve
Un’eccezione è un oggetto che descrive una situazione anomala o di errore
L’eccezioni vengono lanciate da una parte di un programma e possono essere raccolte e gestite da altre parti del programma
Un programma può perciò essere suddiviso nel normale flusso d’esecuzione e in quello eccezionale
Anche un errore è rappresentato come un oggetto Java, ma solitamente rappresenta una situazione non recuperabile e da non gestire
Gestire l’eccezioni
Java ha un insieme predefinito di eccezioni ed errori che possono accadere durante l’esecuzione di un programma
3 modi di gestire l’eccezioni:
– Ignorarle
– Gestirle quando avvengono
– Gestirle altrove nel programma
La scelta del modo di gestire gli eventi anomali o eccezionali è un’importante caratteristica del disegno del programma
Ignorare l’eccezioni
Se un’eccezione è ignorata da un programma, questo terminerà producendo un messaggio opportuno
Il messaggio mostra la traccia dello stack delle chiamate dei metodi con l’indicazione:
– dell’errore
– della linea in cui l’eccezione si è verificata
– dellle chiamate di metodi che hanno portato all’eccezione
Esempi
Zero.java può causare un’eccezionejava.lang.ArithmeticException: / by zero
at Zero.calcolaQuoziente(Zero.java:27)at Zero.main(Zero.java:21)
Exception in thread "main" Process Exit...
BasicArray_eccezione.java causa l’eccezionejava.lang.ArrayIndexOutOfBoundsException
at BasicArray_eccezione.main(BasicArray_eccezione.java:30)
Exception in thread "main" Process Exit...
Esempi
Postfissa.java può causare eccezioni
java.util.EmptyStackExceptionat java.util.Stack.peek(Stack.java:82)at java.util.Stack.pop(Stack.java:64)at Postfissa.elabora(Postfissa.java:37)at Postfissa.main(Postfissa.java:21)
Exception in thread "main" Process
java.lang.NumberFormatException: 1=at java.lang.Integer.parseInt(Integer.java:423)at java.lang.Integer.<init>(Integer.java:549)at Postfissa.elabora(Postfissa.java:42)at Postfissa.main(Postfissa.java:21)
Exception in thread "main" Process Exit...
Gestire l’eccezioni
Occorre processare l’eccezione quando accade, la linea di codice che lancia l’eccezione deve essere eseguita in un blocco try.
Un blocco try è seguito da 1 o più clausole catch, che contengono il codice per gestire l’eccezione
Ogni clausola catch è associata ad un tipo d’eccezione e viene chiamata exception handler
Quando si solleva un’eccezione, la computazione prosegue fino alla prima clausola catch che corrisponde al tipo d’eccezione sollevata
L’istruzione try
Si tenta di eseguire il codice e se si intercetta un’eccezione si cerca di porre rimediotry {
blocco_1} catch (tipo_eccezione identificatore){
blocco_2}
L’istruzione try identifica un blocco d’istruzioni in cui può verificarsi un’eccezione
La clausola catch
Un blocco try è seguito da una o più clausole catch, che specificano quali eccezioni vengono gestite
– Ogni clausola catch corrisponde a un tipo di eccezione sollevata
Quando si verifica un’eccezione, la computazione continua con la prima clausola che corrisponde all’eccezione sollevata
Divisione.java modifica Zero.java Postfissa_e.java ProductCodes.java
La clausola finally
Un’istruzione try può essere seguita da una clausola finally opzionale
Le istruzioni della clausola finally vengono sempre eseguite:
– Se non viene sollevata nessuna eccezione, vengono eseguite dopo che si è concluso il blocco try
– Se si verifica un’eccezione, vengono eseguite dopo le istruzioni della clausola catch appropriata
Rientro dai metodi in caso d’eccezioni
Normalmente se un metodo main richiama il metodo_1 che richiama il metodo_2 che richiama il metodo_3, il controllo passa dal main al metodo_1 al metodo_2 al metodo_3 e quando questo si conclude ritorna al metodo_2 che a conclusione lo passa al metodo_1 e quindi al main
Se si verifica un’eccezione durante l’esecuzione del metodo_3 il controllo viene passato diversamente
Propagazione dell’eccezioni
Se l’eccezione non viene intercettata e gestita dove si verifica, può ancora essere trattata a un livello più alto
L’eccezioni si propagano attraverso la gerarchia delle chiamate di metodi finché non vengono intercettate e gestite
Propagation.java con la classe ExceptionScope.java
L’istruzione throw
Un programmatore può definire un’eccezione estendendo una classe– La classe Exception o una sua sottoclasse
L’eccezioni vengono sollevate con l’istruzione throw Solitamente un’istruzione throw è inclusa in
un’istruzione if che valuta una condizione per verificare se deve essere sollevata l’eccezione
CreatingExceptions.java con l’eccezione EccezioneFuoriIntervallo.java
CreatingExceptions_2.java
Classificazione dell’eccezioni
Le eccezioni possono essere controllate– Dovute a eventi esterni al programma
Cercare di accedere a una pagina web inesistente Cercare una funzione di libreria che manca
– Si chiamano controllate perché il compilatore controlla che vengano esplicitamente indicate e intercettate
O non controllate– Dovute al programma e che potrebbero essere
evitate
Eccezioni controllate
Un’eccezione controllata deve essere raccolta da un metodo in una clausola catch o deve essere nella lista delle clausole throws di ciascun metodo che possa lanciare l’eccezione o propagarla
La clausola throws deve essere dichiarata nell’intestazione del metodo
Il compilatore segnala se un’eccezione controllata non viene gestita propriamente
Eccezioni non controllate
Non richiedono una gestione esplicita con la clausola throws
L’eccezioni non controllate in Java sono quelle che si verificano a run time
Discendono da RuntimeException o da una sua classe discendente
Tutte le altre sono controllate
Errori
Gli errori sono simili alle eccezioni RuntimeException o ai suoi discendenti
– Gli errori non devono essere controllati
– Gli errori non richiedono una clausola throws
La gerarchia di classe delle eccezioni
Object
Throwable
ErrorException
LinkageError
Virtual MachineError
AWTError
RuntimeException
ClassNotFoundException
NullPointerException
IndexOutOfBoundException
ArthemticException
NoSuchMethodException
Eccezioni non controllate
Nuove definizioni d’eccezione
Tutte le nuove classi che estenono la gerarchia precedente o– Discendono da RuntimeException e quindi
non sono controllate o– Disecendono da Exception e quindi sono
controllate I metodi che le lanciano dovranno dichiararlo
nell’intestazione con la clausola throws Un metodo che può lanciare un’eccezione controllata
dovrà dichiararlo
Propagazione e gestione dell’eccezioni controllate
Un metodo che può sollevare un eccezione controllata deve dichiararlo con la clausola throws
A sua volta un metodo che lo richiama deve intercettarla o dichiararla, cioè deve:– Gestire l’eccezione con la coppia try-catch o– Dichiarare a sua volta che potrà sollevare
l’eccezione nella clausola throws
Il package java.awt
• Gestione dell’I/O orientato alla grafica: le finestre
• Sviluppo di interfacce utente grafiche indipendenti dalla piattaforma: astrazione delle caratteristiche comuni
• Le classi di java.awt:
- contenitori - controlli- gestori di layout
Concetti fondamentali sulle finestre
-AWT definisce una gerarchia di classi di finestre in cui ogni livello
prevede una maggiore funzionalità e specificità.
- Le classi di finestre più comuni sono Panel e Frame
-In cima alla gerarchia delle classi di AWT si trova la classe
Component, che incapsula tutti gli atributi di un componente visivo:
tutti gli elementi di interfaccia utente che compaiono sullo schermo sono
derivati da sottoclassi di Component
Gerarchia delle classi AWT
Component
Window
Container
Panel
Frame
TextField
TextArea
Checkbox
Scrollbar
List
Label
Dialog
Button
Canvas
FileDialog
Metodi di (ri)visualizzazione
public void paint(Graphics g)visualizza il contenuto della finestra all’interno dell’ambientegrafico g
void repaint( )fa in modo che l’ambiente run-time esegua una chiamata diupdate( ), che a sua volta chiama paint( )
void show( )visualizza la finestra
void hide( )nasconde la finestra
JAVA e Internet: documenti attivi
DOCUMENTI
Server
elementi passivi
elementi attivi:Applet
Client
SICUREZZA + PORTABILITA’Bytecode e sistema run-time
Applet
• Piccola applicazione con limitato accesso alle risorse del client
• Legame con HTML: il tag Applet per eseguire applet JAVA
• Accesso via Internet, istallazione ed esecuzione automatica come parte di un documento web
• Struttura differente rispetto alle normali applicazioni
• Eredità da Panel: una Applet è una finestra che esegue codice
import java.awt.*;import java.applet.*;class AppletHelloWorld extends Applet {
public void paint(Graphics g) { g.drawString(“Hello, www world”, 20, 20);}
}
Esecuzione di Applet
• Visualizzatore di applet: Appletviewer (fornito con JDK)
• Browser web JAVA-compatibile (HotJava, Netscape Communicator, etc.)
• Documenti HTML con tag applet per lanciare l’esecuzione
<applet code = “HelloWorldRivisitato” width=200 height=60 ></applet>
• Le applet non hanno bisogno di main
• Interfaccia grafica fornita da AWT
• Esecuzione event-driven: risposta rapida agli eventi e restituzione del
controllo
Ciclo di vita di un’applet
SISTEMA RUN-TIME
init
start
stop
destroy
caricamento
visita oRivisita della pagina
passaggioad altre pagine
uscita
Struttura di un’applet
Generalmente si realizza un’applet estendendo la classe Applet e ridefinendo i metodi:
in Applet
init( )start( )stop( )destroy( )
in Component
paint( )update( )
Scheletro di un’applet
import java.awt.*; // SCHELETRO DI UNA APPLETimport java.applet.*;
/* <applet code=“AppletSkel” width=300 heigth=100 > </applet>*/public class AppletSkel extends Applet {
public void init( ) { // chiamato sempre per primo// operazioni di inizializzazione
}
public void start( ) { // chiamato ogni volta che l’applet (ri)parte// parte o riparte l’esecuzione
}
public void stop( ) { // chiamato quando l’applet viene bloccata// operazioni per sospendere l’esecuzione
}
public void destroy( ) { // ultimo chiamato: l’applet termina// operazioni terminali
}public void paint(Graphics g ) { // chiamato per visualizzare l’applet
// mostra il contenuto della finestra}
}
Metodi della classe Applet
• Metodi relativi ai comandi HTML URL getCodeBase( ) rest. l’URL dell’applet URL getDocumentBase( ) rest. l’URL del documento HTML che l’ha chiamata String getParameter(String nomePar) rest. il parametro associato a nomePar
• Metodi per caricare/eseguire video e audio AudioClip getAudioClip(URL url) rest. un oggetto che incapsula un brano Image getImage(URL url) rest. un oggetto che incapsula un’immagine void play(URL url) esegue il brano
• Metodi relativi all’Applet void showStatus(String str) mostra una stringa nella barra di stato del browser void resize(Dimension dim) ridimensiona l’applet secondo le dimensioni specif. bool isActive( ) rest. true se l’applet è stata avviata, false se è stata arrestata
Pagine Web e Applets JAVA
• Le pagine web contengono oggetti multimediali (testo, video, suoni),
collegamenti ipertestuali, e applet
• I browser JAVA-compatibili consentono di caricare, verificare ed eseguire applet JAVA
• Le librerie standard di JAVA forniscono supporto per le funzionalità
tipiche delle applet - Applet API (Application Programming Interface)
- Comunicare con altri computer su Internet (operazioni Tcp/Ip e URL)
- Elaborare grafica (operazioni di disegno e immagini sullo schermo )
- Gestire la GUI (manipolare finestre, bottoni, etc., tramite AWT)
- Eseguire effetti sonori
Inserire un’applet in una pagina web
<title>Arthur’s Home Page</title><h1>Welcome to my home page!</h1>This page is still under construction<p><applet code=JackhammerDuke.class
width=300 height=80></applet><address>[email protected]</address>
Server
ClientFile di
comandiHTML
Internet
Webbrowser
Specificare parametri per applet da HTML
• Personalizzare un’applet
• Modificarne gli aspetti
• Usarla in modi differenti<title>Due Animazioni</title><h1>Two animations using the same applet</h1><p><applet code=ImageLoop.class width=80 height=80><param name=numImage value=10><param name=image value=duke><param name=pause value=100></applet><p><applet code=ImageLoop.class width=80 height=80><param name=numImage value=8><param name=image value=orologio><param name=pause value=100></applet>