Lucidi - Vincenzo Marra - Università degli Studi di Milano

Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Programmazione 1
Lezione 5
Vincenzo Marra
[email protected]
Dipartimento di Matematica Federigo Enriques
Università degli Studi di Milano
2 aprile 2014
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Incrementi e decrementi
È comune l’uso dell’istruzione di post-incremento:
i++;
dove i è, per esempio, una variabile di tipo int.
(?)
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Incrementi e decrementi
È comune l’uso dell’istruzione di post-incremento:
i++;
dove i è, per esempio, una variabile di tipo int.
L’effetto dell’istruzione è di incrementare il valore di i
di uno. Per esempio, se i vale 5, dopo l’istruzione (?) il
valore di i è 6.
(?)
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Incrementi e decrementi
È comune l’uso dell’istruzione di post-incremento:
i++;
(?)
dove i è, per esempio, una variabile di tipo int.
L’effetto dell’istruzione è di incrementare il valore di i
di uno. Per esempio, se i vale 5, dopo l’istruzione (?) il
valore di i è 6.
È possibile anche l’uso dell’istruzione di pre-incremento:
++i;
che ha lo stesso effetto di (?), ma con una importante
differenza nella semantica.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
In una espressione composta in cui compaia il post-incremento:
i++
prima si usa il valore della variabile i e poi lo si incrementa di uno.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
In una espressione composta in cui compaia il post-incremento:
i++
prima si usa il valore della variabile i e poi lo si incrementa di uno.
In una espressione composta in cui compaia il pre-incremento:
++i
prima si incrementa il valore della variabile di uno, e poi si
usa il valore risultante.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
In una espressione composta in cui compaia il post-incremento:
i++
prima si usa il valore della variabile i e poi lo si incrementa di uno.
In una espressione composta in cui compaia il pre-incremento:
++i
prima si incrementa il valore della variabile di uno, e poi si
usa il valore risultante.
Per esempio, se i vale 5, dopo l’istruzione:
int x = i++;
x vale 5. Invece, dopo l’istruzione
int x = ++i;
x vale 6. In entrambi i casi i varrà 6 dopo l’istruzione.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
In una espressione composta in cui compaia il post-incremento:
i++
prima si usa il valore della variabile i e poi lo si incrementa di uno.
In una espressione composta in cui compaia il pre-incremento:
++i
prima si incrementa il valore della variabile di uno, e poi si
usa il valore risultante.
Per esempio, se i vale 5, dopo l’istruzione:
int x = i++;
x vale 5. Invece, dopo l’istruzione
int x = ++i;
x vale 6. In entrambi i casi i varrà 6 dopo l’istruzione.
Considerazioni analoghe valgono per gli operatori di predecremento: --i e di post-decremento: i--.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
È diffuso l’uso degli operatori ++ e -- assieme all’istruzione
for.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
È diffuso l’uso degli operatori ++ e -- assieme all’istruzione
for.
Supponiamo ad esempio di voler visualizzare i primi 100
numeri naturali in ordine crescente. Possiamo scrivere:
for(int i=1; i<=100; i++)
printf("%d",i);
Se invece volessimo visualizzare i primi 100 numeri naturali in ordine decrescente, potremmo scrivere:
for(int i=100; i>=1; i--)
printf("%d",i);
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
È diffuso l’uso degli operatori ++ e -- assieme all’istruzione
for.
Supponiamo ad esempio di voler visualizzare i primi 100
numeri naturali in ordine crescente. Possiamo scrivere:
for(int i=1; i<=100; i++)
printf("%d",i);
Se invece volessimo visualizzare i primi 100 numeri naturali in ordine decrescente, potremmo scrivere:
for(int i=100; i>=1; i--)
printf("%d",i);
Nel primo esempio è equivalente scrivere i=i+1, i++ o ++i;
nel secondo è equivalente scrivere i=i-1, i-- o --i.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Altri operatori di assegnamento
Abbiamo visto che = è l’operatore di assegnamento. Ve ne
sono altri da esso derivati, fra i quali:
+=, -=, *=, /=, %=.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Altri operatori di assegnamento
Abbiamo visto che = è l’operatore di assegnamento. Ve ne
sono altri da esso derivati, fra i quali:
+=, -=, *=, /=, %=.
Esempio:
int i=2;
i=i+3;
\\dopo questa istruzione i vale 5
Si può anche scrivere:
int i=2;
i+=3;
\\dopo questa istruzione i vale 5
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
i=i+3 : Valuta il membro destro (ossia valuta i, valuta 3,
e computa la somma dei risultati), valuta il membro sinistro (ossia valuta di nuovo i) e assegna il primo risultato
al secondo.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
i=i+3 : Valuta il membro destro (ossia valuta i, valuta 3,
e computa la somma dei risultati), valuta il membro sinistro (ossia valuta di nuovo i) e assegna il primo risultato
al secondo.
i+=3 : Valuta il membro destro (ossia valuta 3), valuta il
membro sinistro (ossia valuta i), e assegna la somma del
primo e del secondo risultato al secondo.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
i=i+3 : Valuta il membro destro (ossia valuta i, valuta 3,
e computa la somma dei risultati), valuta il membro sinistro (ossia valuta di nuovo i) e assegna il primo risultato
al secondo.
i+=3 : Valuta il membro destro (ossia valuta 3), valuta il
membro sinistro (ossia valuta i), e assegna la somma del
primo e del secondo risultato al secondo.
Nel primo caso i è valutata due volte, nel secondo caso
una volta.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
i=i+3 : Valuta il membro destro (ossia valuta i, valuta 3,
e computa la somma dei risultati), valuta il membro sinistro (ossia valuta di nuovo i) e assegna il primo risultato
al secondo.
i+=3 : Valuta il membro destro (ossia valuta 3), valuta il
membro sinistro (ossia valuta i), e assegna la somma del
primo e del secondo risultato al secondo.
Nel primo caso i è valutata due volte, nel secondo caso
una volta.
Negli esempi semplici come questo la differenza è trascurabile. Vedremo più avanti che in esempi più complessi le
cose cambiano.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
C’è però una differenza fra la semantica di = e quella di +=.
i=i+3 : Valuta il membro destro (ossia valuta i, valuta 3,
e computa la somma dei risultati), valuta il membro sinistro (ossia valuta di nuovo i) e assegna il primo risultato
al secondo.
i+=3 : Valuta il membro destro (ossia valuta 3), valuta il
membro sinistro (ossia valuta i), e assegna la somma del
primo e del secondo risultato al secondo.
Nel primo caso i è valutata due volte, nel secondo caso
una volta.
Negli esempi semplici come questo la differenza è trascurabile. Vedremo più avanti che in esempi più complessi le
cose cambiano.
Considerazioni analoghe valgono per gli altri operatori
elencati sopra.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Esercizio in classe: La Trattoria
Esercizio.
Scrivere un programma che presenti all’utente il menu seguente.
1
Primo – 8.5 euro
2
Secondo – 10 euro
3
Contorno – 4 euro
4
Frutta – 3.5 euro
5
Conto
L’utente è libero di ordinare piatti dal menu in qualunque ordine e
quantità. Dopo ogni ordinazione il programma scrive Primo servito
(o Secondo ecc.) e visualizza nuovamente il menu. Se ciò che digita
l’utente non corrisponde a una voce del menu, il programma visualizza un messaggio d’errore e torna al menu. Quando l’utente chiede il
conto, il programma visualizza l’importo totale dovuto e termina.
Gli operatori ++ e +=
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Esercizi in classe
Introduzione agli array
Esercizi in classe
trattoria.c
#include "Prog1/IO.h" //Per la funzione leggi_car e il tipo definito String
int main(void)
{
char sc;
// scelta dell’utente
int itera=1;
// termina programma quando ==0
double conto=0;
// importo totale dovuto
String m="1. Primo\t8.5 e.\n2. Secondo\t10 e.\n3. Contorno\t4 e.\n4. Frutta\t3.5 e.\n5. Conto.\n";
do{
printf("%s> ",m);
// visualizza il menu e il prompt >
sc=leggi_car();
// legge scelta dell’utente
switch (sc){
case ’1’:
break;
case ’2’:
break;
case ’3’:
break;
case ’4’:
break;
case’5’:
printf("Primo servito.\n");
conto+=8.5;
printf("Secondo servito.\n");
conto+=10;
printf("Contorno servito.\n");
conto+=4;
printf("Frutta servita.\n");
conto+=3.5;
printf("Ecco il suo conto: %g euro. Grazie e arrivederci.\n",conto);
itera=0; //impostando itera=0 si ottiene l’uscita dal while
break;
default:
printf("Scelta inesistente.\n");
break;
}
} while (itera); // continua fino a che itera==0
return 0;
}
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Esercizio in classe: Distanza euclidea
Esercizio.
Scrivere un programma che chieda all’utente di inserire le coordinate
di due punti nel piano R × R, e visualizzi poi la loro distanza nella
metrica euclidea. Si usi il tipo double.
Suggerimento. Per estrarre la radice quadrata si usi la funzione
double sqrt(double) contenuta nel file di intestazione math.h della
libreria standard.
Gli operatori ++ e +=
1
2
Esercizi in classe
Introduzione agli array
Esercizi in classe
distanza.c
#include "Prog1/IO.h" //Include anche stdio.h
#include <math.h> //Per la funzione sqrt
3
4
5
6
7
8
9
int main(void)
{
double
double
double
double
px
py
qx
qy
=
=
=
=
leggi_double("Inserisci
leggi_double("Inserisci
leggi_double("Inserisci
leggi_double("Inserisci
px:
py:
qx:
qy:
");
");
");
");
10
printf("La distanza fra (%g,%g) e (%g,%g) e’ ",px,py,qx,qy);
11
12
double d=sqrt( (px-qx)*(px-qx) + (py-qy)*(py-qy) );
13
14
printf("%g.\n",d);
15
16
return 0;
17
18
}
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Esercizio in classe: Distanza euclidea iterata
Esercizio.
Modificare il programma scritto per risolvere l’esercizio precedente di
modo che l’utente abbia la possibilità di iterare il calcolo della distanza per una nuova coppia di punti. Una volta finito un primo calcolo,
il programma chiede all’utente se intende continuare, ricominciando
da capo in caso di risposta affermativa e terminando l’esecuzione in
caso contrario.
Suggerimento. Per decidere se continuare o no, il programma chiede
all’utente di inserire una risposta Sì/No. Essa può essere acquisita
leggendo un carattere dalla console con la funzione char
leggi_car() della libreria Prog1. Per semplicità d’implementazione
si può poi decidere di terminare l’esecuzione se il carattere letto è
'N', e continuare in qualunque altro caso.
Gli operatori ++ e +=
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Esercizi in classe
Introduzione agli array
distanza2.c
#include "Prog1/IO.h" //Include anche stdio.h
#include <math.h> //Per la funzione sqrt
int main(void)
{
char sc; //scelta utente: continua o no
do
{
double
double
double
double
px
py
qx
qy
=
=
=
=
leggi_double("Inserisci
leggi_double("Inserisci
leggi_double("Inserisci
leggi_double("Inserisci
px:
py:
qx:
qy:
");
");
");
");
printf("La distanza fra (%g,%g) e (%g,%g) e’ ", px,py,qx,qy);
double d=sqrt( (px-qx)*(px-qx) + (py-qy)*(py-qy) );
printf("%g.\n",d);
printf("Continuare? (S/N) ");
sc=leggi_car();
} while (sc!=’N’); //continua se sc non e’ N
return 0;
}
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Morale
La regola delle quattro P
Prima Progettare Poi Programmare
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Morale
La regola delle quattro P
Prima Progettare Poi Programmare
La scrittura del codice è solo l’ultimo passo nella soluzione del
problema. Come nella comunicazione ordinaria, prima di cominciare a parlare (o scrivere) sarebbe bene sapere cosa si vuol
dire.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Morale
La regola delle quattro P
Prima Progettare Poi Programmare
La scrittura del codice è solo l’ultimo passo nella soluzione del
problema. Come nella comunicazione ordinaria, prima di cominciare a parlare (o scrivere) sarebbe bene sapere cosa si vuol
dire.
Scrivere codice non è un’attività lineare: non ha senso pensare
di scrivere anche solo 50 righe di codice dalla prima all’ultima
in bella copia, come fosse un dettato. In effetti, la stesura del
codice di un programma è forse più simile alla costruzione di un
oggetto che non invece alla composizione di un testo.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Morale
La regola delle quattro P
Prima Progettare Poi Programmare
Come abbiamo visto negli esempi la stesura di un programma
procede per approssimazioni successive, avendo cura di verificare
il corretto funzionamento di quanto già scritto man mano che si
procede ad una fase successiva.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Morale
La regola delle quattro P
Prima Progettare Poi Programmare
Come abbiamo visto negli esempi la stesura di un programma
procede per approssimazioni successive, avendo cura di verificare
il corretto funzionamento di quanto già scritto man mano che si
procede ad una fase successiva.
Repetita iuvant. Non si riesce a procedere come nel punto precedente, per approssimazioni successive, se non si ha chiara in
mente (o su carta, nei casi meno semplici) la struttura complessiva del programma che si sta scrivendo. Di nuovo, quindi:
PPPP.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Gli array
In gergo informatico, un array è una collezione di dati
(solitamente tutti dello stesso tipo, diciamo T) cui si può
accedere tramite un indice, che è un valore intero non
negativo.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Gli array
In gergo informatico, un array è una collezione di dati
(solitamente tutti dello stesso tipo, diciamo T) cui si può
accedere tramite un indice, che è un valore intero non
negativo.
In italiano si usa il termine inglese array, oppure a volte il
termine vettore. Si parla di array di T o di vettore di T.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Gli array
In gergo informatico, un array è una collezione di dati
(solitamente tutti dello stesso tipo, diciamo T) cui si può
accedere tramite un indice, che è un valore intero non
negativo.
In italiano si usa il termine inglese array, oppure a volte il
termine vettore. Si parla di array di T o di vettore di T.
La rappresentazione tipica di una array di T nella memoria centrale del computer è costituita da una successione
di celle di memoria adiacenti, ciascuna atta a memorizzare un dato del tipo T. L’array ha una dimensione o lunghezza: il numero di elementi del tipo T che è in grado di
memorizzare.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Il modo tipico di raffigurarsi, ad esempio, un array di int
di lunghezza 5 è il seguente:
12 0 5 4 5
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Il modo tipico di raffigurarsi, ad esempio, un array di int
di lunghezza 5 è il seguente:
12 0 5 4 5
Le celle sono numerate consecutivamente a partire da zero:
Indice
0 1 2 3 4
Array
12 0 5 4 5
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Il modo tipico di raffigurarsi, ad esempio, un array di int
di lunghezza 5 è il seguente:
12 0 5 4 5
Le celle sono numerate consecutivamente a partire da zero:
Indice
0 1 2 3 4
Array
12 0 5 4 5
Se il nome di questo array è pippo, allora per accedere
all’elemento i -esimo su usa la notazione pippo[i]. Per
esempio,
pippo[3]
è un’espressione di tipo int e valore 4. Invece,
pippo[0]
è un’espressione di tipo int e valore 12.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Nota Bene 1. In C la numerazione comincia da 0: nell’esempio, l’array pippo ha dimensione 5, il suo primo
elemento è pippo[0], e il suo ultimo elemento è pippo[4].
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Nota Bene 1. In C la numerazione comincia da 0: nell’esempio, l’array pippo ha dimensione 5, il suo primo
elemento è pippo[0], e il suo ultimo elemento è pippo[4].
Nota Bene 2. Nell’esempio, l’espressione
pippo[6]
è sintatticamente corretta, ma il suo uso costituirebbe un
errore di programmazione: la posizione numero 6 di pippo
non esiste.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Nota Bene 1. In C la numerazione comincia da 0: nell’esempio, l’array pippo ha dimensione 5, il suo primo
elemento è pippo[0], e il suo ultimo elemento è pippo[4].
Nota Bene 2. Nell’esempio, l’espressione
pippo[6]
è sintatticamente corretta, ma il suo uso costituirebbe un
errore di programmazione: la posizione numero 6 di pippo
non esiste.
Sintassi. Per dichiarare un array di int di nome pippo e
dimensione 5 si usa l’istruzione:
int pippo[5];
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Nota Bene 1. In C la numerazione comincia da 0: nell’esempio, l’array pippo ha dimensione 5, il suo primo
elemento è pippo[0], e il suo ultimo elemento è pippo[4].
Nota Bene 2. Nell’esempio, l’espressione
pippo[6]
è sintatticamente corretta, ma il suo uso costituirebbe un
errore di programmazione: la posizione numero 6 di pippo
non esiste.
Sintassi. Per dichiarare un array di int di nome pippo e
dimensione 5 si usa l’istruzione:
int pippo[5];
Vedremo adesso degli esempi di utilizzo degli array analizzando brani di codice. La discussione sugli array proseguirà per varie lezioni, e avremo modo di approfondire a
lungo l’argomento.
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
array1.c
1
#include <stdio.h>
2
3
4
5
6
7
int main(void)
{
//dichiara array di 10 int
//da v[0] a v[9]
int v[10];
8
for(int i=0; i<10; i++)
//stampa elemento i-esimo,
//non inizializzato
printf("%d\n",v[i]);
9
10
11
12
13
return 0;
14
15
}
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
array2.c
1
#include <stdio.h>
2
3
4
5
6
7
8
9
int main(void)
{
//dichiara array di 10 int
//da v[0] a v[9]
int v[10];
//variabile indice
int i;
10
for(i=0; i<10; i++)
v[i]=0; //iniz. elemento i-esimo a 0
11
12
13
for(i=0; i<10; i++)
printf("%d\n",v[i]); //stampa elemento i-esimo
14
15
16
return 0;
17
18
}
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
array3.c
1
#include <stdio.h>
2
3
4
5
6
7
int main(void)
{
//dichiara array di 10 int
//da v[0] a v[9]
int v[10];
8
//ERRORE: accede a elemento inesistente
printf("%d\n",v[100]);
9
10
11
return 0;
12
13
}
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
array4.c
1
#include <stdio.h>
2
3
4
5
6
7
8
int main(void)
{
int v[10];
int w[10];
//variabile indice
int i;
9
for(i=0; i<10; i++)
v[i]=i*i; //iniz. elemento i-esimo a i^2
10
11
12
for(i=0; i<10; i++)
w[9-i]=v[i]; //w e’ v in ordine inverso
13
14
15
for(i=0; i<10; i++)
printf("%d\t%d\n",v[i],w[i]);
16
17
18
return 0;
19
20
}
Esercizi in classe
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
Esercizi in classe
Esercizio in classe: Istogrammi orizzontali
Esercizio.
Scrivere un programma che chieda all’utente di inserire dieci valori
interi positivi, e visualizzi un istogramma (orizzontale) di asterischi *
che li rappresenti.
Esempio. Se i 10 valori in ingresso fossero, nell’ordine,
2, 1, 5, 4, 4, 4, 6, 1, 7, 4, il programma dovrebbe visualizzare:
**
*
*****
****
****
****
******
*
*******
****
Gli operatori ++ e +=
Esercizi in classe
Introduzione agli array
isto.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "Prog1/IO.h" //Per leggi_int
int main(void)
{
int v[10];
int i;
//lettura
for(i=0; i<10; i++)
while( (v[i]=leggi_int("Inserisci prossimo intero: ")) <= 0 )
printf("Solo valori positivi: reinserire.\n");
//scrittura
for(i=0; i<10; i++)
{
for(int j=0;j<v[i];j++)
printf("*");
printf("\n");
}
return 0;
}
Esercizi in classe

Download Report