Programmare con C++ - HOEPLI.it

Cesare Rota
Programmare con C++
EDITORE ULRICO HOEPLI MILANO

Copyright © Ulrico Hoepli Editore S.p.A. 2009
via Hoepli 5, 20121 Milano (Italy)
tel. +39 02 864871 – fax +39 02 8052886
e-mail hoepli@hoepli.it
www.hoepli.it
Tutti i diritti sono riservati a norma di legge
e a norma delle convenzioni internazionali
ISBN 978-88-203-4248-7
Ristampa:
4 3 2 1 0 2009 2010 2011 2012 2013
Realizzazione editoriale
ART Servizi Editoriali S.p.A. - Bologna
www.art.bo.it
Coordinamento editoriale: Monica Monari
Redazione: Barbara Megali
Progetto grafico: Marina Baldisserri
Impaginazione: Sonia Bertusi
Copertina: MN&CG S.r.l., Milano
Stampa: Art Grafiche Franco Battaia S.r.l. - Zibido San Giacomo (MI)
Printed in Italy

Presentazione 5
Sezione 1 - Premesse 7
U.D. 1 - Sistemi di numerazione 8
1.1 Sistema di numerazione decimale 9
1.2 Notazione polinomiale 9
1.3 Numeri decimali 10
1.4 Sistema di numerazione binario 11
1.5 Conversione da base 2 a base 10 12
1.6 Somma e sottrazione nel sistema
binario 13
1.7 Sistema di numerazione esadecimale 14
1.8 Conversione da binario a esadecimale
e viceversa 16
Esercizi 18
U.D. 2 - Codifica delle informazioni 20
2.1 Introduzione 21
2.2 Rappresentazione dei caratteri 22
2.3 Rappresentazione interna
dei numeri interi 24
2.4 Rappresentazione dei numeri reali 28
Esercizi 31
Sezione 2 - Primi elementi
di programmazione 33
U.D. 3 - Introduzione a C++ 34
3.1 Primo programma 35
3.2 Analisi del codice 38
3.3 Definizione e assegnazione 40
3.4 Tipi di dato 42
3.5 Tipo di dato intero 43
3.6 Tipo char 44
3.7 Numeri in virgola mobile 46
3.8 Casting 48
3.9 Tipo booleano 48
3.10 Costanti 49
Esercizi 51
U.D. 4 - Visualizzazione e acquisizione 54
4.1 Acquisizione delle informazioni:
il metodo cin 55
Indice
4.2 Output formattato 58
4.3 Caratteri di escape 62
4.4 Uso di “\\” e del carattere “@” 63
Esercizi 64
U.D. 5 - Operatori 66
5.1 Operatori aritmetici 67
5.2 Operatori aritmetici composti 73
5.3 Operatori relazionali 78
5.4 Operatori logici 80
Esercizi 86
Sezione 3 - Organizzazione degli algoritmi 89
U.D. 6 - Algoritmi e pseudocodifica 90
6.1 Analisi del problema 91
6.2 Primo esempio 92
6.3 Algoritmi 94
6.4 Dati e istruzioni 96
6.5 Istruzioni di assegnamento 97
6.6 Istruzioni di ingresso e di uscita
dei dati 99
6.7 Teorema di Jacopini-Böhm 100
6.8 Struttura di alternativa 102
6.9 Struttura di ripetizione 104
6.10 Considerazioni sulla pseudocodifica 107
Esercizi 109
U.D. 7 - Istruzioni di selezione 112
7.1 Istruzione if 113
7.2 Istruzione if..else 115
7.3 If nidificati 118
7.4 Istruzione switch
(selezione multipla) 120
7.5 Raggruppamento dei case 122
Esercizi 125
U.D. 8 - Istruzioni di ripetizione 127
8.1 Istruzione while 128
8.2 Tabulazione 130
8.3 Istruzione do.. while 132
8.4 Istruzione for 134
Esercizi 139
3

4
Indice
U.D. 9 - Le funzioni 142
9.1 Le funzioni 143
9.2 La funzione più importante 144
9.3 Definizione delle funzioni 147
9.4 Ambito delle variabili 148
9.5 Variabili locali e globali 151
9.6 Valori di ritorno 152
9.7 Passaggio dei parametri
per valore 153
9.8 Passaggio dei parametri
per riferimento 157
9.9 Ricorsione 161
9.10 Funzioni matematiche 163
Esercizi 165
Sezione 4 - Strutture dei dati 167
U.D. 10 - Enumerazioni e array 168
10.1 Introduzione 169
10.2 Tipi enumerativi (enumerazioni) 169
10.3 Tipo vettore 171
10.4 Vettori in C++ 172
10.5 Caricamento di un vettore
in memoria 176
10.6 Array di dimensione variabile 178
10.7 Matrici 180
10.8 Passaggio di un vettore come
parametro a una funzione 187
Esercizi 190
U.D. 11 - Stringhe e strutture 192
11.1 Definizione di stringa 193
11.2 Lunghezza di una stringa 195
11.3 Concatenazione ed estrazione 197
11.4 Confronti tra stringhe 200
11.5 Caratteri e stringhe C 201
11.6 Dichiarazione di una struttura 202
11.7 Metodi costruttori 204
Esercizi 207
Sezione 5 - Classi e oggetti 209
U.D. 12 - Concetti generali 210
12.1 Introduzione alla OOP 211
12.2 Incapsulazione 211
12.3 Polimorfismo 212
12.4 Ereditarietà 213
12.5 Introduzione alle classi 215
12.6 Terminologia e rappresentazione
grafica 216
12.7 Dichiarazione degli oggetti 218
Esercizi 222
U.D. 13 - Polimorfismo ed ereditarietà 223
13.1 Costruttori 224
13.2 Costruttori parametrizzati 227
13.3 Membri static di una classe 230
13.4 Overloading 234
13.5 Polimorfismo 236
13.6 Ereditarietà 240
Esercizi 249
Sezione 6 - Operare con gli archivi 251
U.D. 14 - Archivi 252
14.1 Definizione di archivio 253
14.2 Dati 254
14.3 Definizione di record 255
14.4 Operazioni fondamentali
sugli archivi 256
14.5 I/O standard e su memoria
di massa 257
14.6 Tipi di archivio 259
14.7 Tipi di accesso 260
Esercizi 261
U.D. 15 - File di testo 262
15.1 Creazione di un file di testo 263
15.2 Lettura di un file di testo 266
15.3 Accodamento 268
Esercizi 271
Sezione 7 - Le eccezioni 273
U.D. 16 - Gestione delle eccezioni 274
16.1 Concetto di anomalia 275
16.2 Eccezioni 277
Esercizi 283
Appendice A - Riepilogo degli operatori 285
Appendice B - Sequenze di caratteri
escape 286
Indice analitico 287

Il presente volume espone, in modo chiaro ed efficace, le caratteristiche del linguaggio C++
e ha il duplice scopo di descriverne la sintassi e di evidenziarne le potenzialità.
In particolare il libro:
si rivolge allo studente come un manuale di facile consultazione per la programmazione;
presenta le basi teoriche per lo sviluppo delle applicazioni informatiche.
Il primo obiettivo si realizza tramite numerosi esempi presenti nel testo, che forniscono
chiare indicazioni sulle caratteristiche sintattiche del linguaggio. Per quanto riguarda le
basi teoriche sono stati messi in rilievo i fondamenti dei cinque argomenti di base per la
programmazione: la rappresentazione dei dati, le strutture di controllo utilizzabili nella
costruzione di un algoritmo, le strutture dei dati, la programmazione orientata agli oggetti
e la gestione dei file.
Il libro è suddiviso in sette sezioni.
Presentazione
1 La sezione Premesse sviluppa gli argomenti della codifica binaria delle informazioni.
2 In Primi elementi di programmazione vengono descritti i concetti di variabile,
costante e tipi di dato, le operazioni di input/output da console e gli operatori aritmetici.
3 Nella sezione Organizzazione degli algoritmi viene introdotta la nozione di algoritmo
e sono descritte le principali strutture di controllo sia in pseudocodifica sia in C++.
4 Nella sezione Strutture dei dati vengono definite le principali strutture statiche dei
dati.
5 L’intera sezione Classi e oggetti è dedicata alle nozioni fondamentali della OOP e
vengono presentati i concetti principali della programmazione orientata agli oggetti
quali l’incapsulamento, il polimorfismo e l’ereditarietà.
6 La sezione Operare con gli archivi spiega le nozioni di base per la definizione degli
archivi di dati.
7 La sezione Le eccezioni descrive gli accorgimenti essenziali per la realizzazione di
applicazioni “robuste”.
Ogni sezione è suddivisa in Unità didattiche le quali contengono un numero limitato di
paragrafi, la cui trattazione è, di norma, contenuta in circa due pagine. Ne risulta un testo
5

6
Presentazione
di facile lettura, che aiuta lo studente a concentrarsi, di volta in volta, su un singolo elemento
del discorso. Tutti i concetti presentati sono accompagnati da un esempio, che
mette in pratica quanto esposto. Ogni esempio contiene un listato di codice, una figura
che illustra una prova di esecuzione del codice proposto e l’analisi dettagliata del codice
stesso; quest’ultima parte dell’esempio presenta una descrizione dettagliata degli aspetti
più significativi del linguaggio C++ presenti nell’esempio.
Per ogni sezione sono indicati gli obiettivi generali che si vogliono raggiungere, mentre
nella prima pagina di ogni Unità didattica è specificato per lo studente “Che cosa imparerai
a fare” e “Che cosa dovrai studiare”. In concreto, gli obiettivi generali presentati all’inizio
di ogni modulo descrivono le capacità che lo studente deve acquisire. Le voci “Che
cosa imparerai a fare” e “Che cosa dovrai studiare” indicano rispettivamente le competenze
e le conoscenze che devono essere apprese dall’alunno.
Considerando l’ampiezza della trattazione, il libro include tutti i contenuti dei programmi
didattici tradizionalmente affrontati nelle classi terze degli istituti tecnici.
In particolare può essere adottato nella classe terza degli Istituti Tecnici Industriali con indirizzo
ABACUS o informatica industriale, in quella degli Istituti Tecnici Commerciali
con indirizzo MERCURIO o programmatori, nonché in quella dei Licei scientifici tecnologici.
L’Autore

†
Obiettivi
generali
Sezione 4
Strutture dei dati
◊ Definire insiemi di dati numerabili
◊ Saper utilizzare schemi logici per organizzare insiemi
complessi di dati
◊ Costruire tabelle di dati omogenei
◊ Manipolare stringhe di caratteri
&U.D.10
Enumerazioni e array
U.D.11 Stringhe e strutture
◊ Raggruppare dati di tipo diverso
Questa sezione contiene

Unità didattica 10
Enumerazioni e array
CHE COSA IMPARERAI A FARE
$ Definire dati di tipo enumerativo
$ Definire un array a una dimensione in C++
$ Caricare un vettore in memoria
$ Definire un vettore a dimensione variabile
$ Definire una matrice
$ Popolare una matrice
$ Visualizzare gli elementi di una matrice
CHE COSA DOVRAI STUDIARE
$ Definizione di tipo enumerativo
$ Concetto di vettore
$ Definizione di vettore
$ Sintassi per la gestione di un vettore
$ Sintassi per la gestione delle matrici

10
Unità didattica
Enumerazioni e array
10.1 Introduzione
Finora abbiamo visto i tipi di dato più comuni e i più facili da utilizzare in C++, cioè i tipi predefiniti:
int, double, bool ecc.
In C++, però, si possono anche utilizzare tipi definiti dal programmatore. Tali nuovi tipi, per poter
essere utilizzati, vanno inseriti nella dichiarazione delle variabili secondo la sintassi consueta:
tipo variabile;
Tutti i dati che compaiono in un programma possiedono uno e un solo tipo, e possono essere di tipo
semplice oppure aggregati in modo complesso.
I tipi di dato semplici sono classificati secondo lo schema gerarchico riportato di seguito.
reali
float double
semplici
ordinali
enumerativi predefiniti
I tipi semplici possono essere float o double, oppure di tipo ordinale; i tipi ordinali possono essere
definiti dal programmatore attraverso i tipi enumerativi, oppure possono appartenere ai tipi ordinali
predefiniti int, bool, char.
Il tipo ordinale si chiama così perché descrive un insieme finito e ordinato di valori,
che possono essere associati a numeri interi positivi.
I tipi ordinali predefiniti e i tipi float e double sono già stati presentati e utilizzati in precedenza.
10.2 Tipi enumerativi (enumerazioni)
int char bool
A volte una variabile può assumere solo una serie di valori definiti all’interno di un insieme discreto
di possibilità. Le enumerazioni sono molto comuni nella vita di tutti i giorni: per esempio, può essere
un’enumerazione la lista dei controlli da eseguire sull’auto prima di affrontare un viaggio: freni,
fari, gomme, olio, tergicristalli, carburante.
169

170
Sezione 4 - Strutture dei dati
Per definire in C++ un’enumerazione si usa la seguente sintassi:
enum nome_enumerazione {elenco_enumerazioni};
dove enum è la parola chiave che introduce l’enumerazione.
Riprendendo la lista di esempio proposta in precedenza, si può scrivere:
enum controlli {freni, fari, gomme, olio, tergicristalli, carburante};
Il nome dell’enumerazione può essere utilizzato per dichiarare variabili di tale tipo, in maniera analoga
alle dichiarazioni di tipo viste in precedenza. Per esempio, potremo scrivere:
controlli check;
La variabile check può assumere uno qualsiasi dei valori della lista dei controlli definita in precedenza.
Per esempio, si può scrivere:
check = gomme;
oppure
if (check == fari) cout

22 //fine programma
23 cout

172
Sezione 4 - Strutture dei dati
Prendiamo, per esempio, l’elenco degli studenti di una classe, così come appare sul registro.
A ogni studente è associato un numero di posizione e ogni numero individua uno studente.
In questo esempio, ogni elemento del vettore è di tipo stringa (per contenere il cognome e nome dello
studente) e ogni elemento è individuato da un numero, detto indice. La dimensione del vettore è 24.
Oppure consideriamo un quadrilatero irregolare in cui ogni lato ha una misura diversa.
Possiamo scrivere:
Ogni elemento dell’esempio precedente è un dato di tipo numerico (la misura del lato) e per ogni
misura è presente un indice che è il numero del lato; la dimensione è 4.
10.4 Vettori in C++
L’istruzione per definire un vettore ha il seguente formato:
dove:
Riprendendo gli esempi del paragrafo precedente, per definire il vettore che contiene i nomi dei 24
studenti di una classe possiamo scrivere:
int dim = 24;
string Studenti [dim];
1 Abbiati Mario
2 Bonaldi Piera
3 Casati Luigi
4 Esposito Salvatore
.. ...
.. ...
24 Vivaldi Giuseppe
LATO MISURA
1 15
2 8
3 7
4 16
tipo nomeVettore [dimensione];
tipo specifica il tipo di dato comune a tutte le componenti;
nomeVettore è il nome collettivo delle componenti del vettore;
dimensione è il numero degli elementi contenuti nel vettore.
4
1 2
3

Per definire le misure dei lati di un quadrilatero:
int dim=4;
int misure [dim];
È buona norma definire la dimensione del vettore come variabile (nel nostro caso: dim): in questo
modo eventuali variazioni della dimensione richiedono un solo intervento nel codice.
In base a questa regola, nell’esempio dell’elenco degli studenti il primo studente (Abbiati Mario) è
individuato dall’indice 0 e l’ultimo (Vivaldi Giuseppe) dall’indice 23.
Quando si lavora con una variabile di tipo vettore, occorre sempre, all’interno del programma, indicare
sia il nome della variabile sia l’indice che individua la componente del vettore che vogliamo trattare;
per esempio, per assegnare al primo elemento del vettore la misura del primo lato, si scrive:
misure[0] = 15
Si noti che l’indice va indicato racchiuso tra parentesi quadre dopo il nome della variabile.
Per assegnare a ciascun lato la misura corrispondente, si scrive:
misure[1] = 8
misure[2] = 7
misure[3] = 16
Dal punto di vista concettuale, possiamo pensare che in memoria è presente una struttura di questo
tipo:
Alcuni esempi di istruzioni sugli elementi di un vettore
Sempre riferendosi alle misure dei lati di un quadrilatero, per scrivere la misura del terzo lato si utilizza
la seguente istruzione:
cout

174
Sezione 4 - Strutture dei dati
Descrizione della soluzione
Le istruzioni per definire l’array e per assegnargli i valori iniziali sono già state viste in questo paragrafo.
Per sommare tutti i lati del quadrato si definisca un ciclo for con l’indice che va da 0 a 3 e che
permette di accedere a tutti e quattro i lati del quadrilatero, vale a dire a tutti e quattro gli elementi
del vettore delle misure.
Pseudocodifica
//struttura dati
vettore delle misure dei lati
//input
//tutti i dati sono definiti all’interno del programma
//output
perimetro
//variabili di lavoro
i //indice per ciclo for
INIZIO
//inizializza il vettore delle misure
misure[0] ← 15
misure[1] ← 8
misure[2] ← 7
misure[3] ← 16
//inizializza perimetro
perimetro ← 0
//visita il vettore
PER i DA 0 A dim – 1
perimetro = perimetro + misure[i] //somma le misure ad 1 ad 1
FINE PER
FINE
scrivi (Perimetro)
Codice
Perimetro.cpp
1 #include
2 using namespace std;
3
4 //INIZIO
5 int main ()
6 {
7 //struttura del vettore
8 const int dim=4;
9 int misure[dim];
10
11 int i; //contatore per ciclo for
12 int perim; //dato di output
13
14 //inizializza il vettore misure

15 misure[0] = 15;
16 misure[1] = 8;
17 misure[2] = 7;
18 misure[3] = 16;
19
20 //inizializza perimetro
21 perim = 0;
22
23 //visita il vettore
24 for(i=0; i

176
Sezione 4 - Strutture dei dati
. . .
14 //inizializza il vettore misure
15 misure[0] = 15;
15 misure[1] = 8;
16 misure[2] = 7;
17 misure[3] = 16;
18 . . .
possono essere sostituite dalla seguente scrittura più “veloce”:
int [] misure = new int [] {15, 8, 7, 16};
Si noti che non è neppure necessario specificare la dimensione del vettore.
...........................................................................................................................................
10.5 Caricamento di un vettore in memoria
Nel paragrafo precedente è stato illustrato un esempio di trattamento di un vettore, ipotizzando che
i suoi valori fossero caricati all’interno del codice del programma. Nell’esempio che segue, viene illustrato
come si può fare in modo che sia l’utente a caricare direttamente in un vettore i valori che
desidera. Inizialmente, consideriamo il caso in cui la dimensione del vettore è nota a priori.
Esempio arrayCarica.........................................................................................................
Consentire l’inserimento da tastiera dei valori di un vettore di interi con dimensione fissa = 5.
Descrizione della soluzione
Dopo avere definito un vettore di 5 interi, si eseguono due “visite” sugli elementi del vettore: la prima
contiene il blocco di istruzioni che permette di caricare i dati inseriti da tastiera in ciascun elemento
del vettore; la seconda viene utilizzata per visualizzare i dati caricati.
Pseudocodifica
//costanti
dimensione = 5
//struttura dati
vettore di 5 interi
//input
serie di 5 numeri
//output
vettore di 5 interi
INIZIO
PER ogni elemento del vettore
richiedi dato
carica dato
FINE PER
PER ogni elemento del vettore
scrivi (elemento)
FINE PER
FINE

Codice
arrayCarica.cpp
1 #include
2 using namespace std;
3
4 //INIZIO
5 int main ()
6 {
7 //definisci il vettore di 5 elementi
8 const int dim = 5;
9
10 //definisci la struttura dati
11 int vett [dim];
12
13 //ciclo for x caricare vettore
14 for (int i=0; i

178
Sezione 4 - Strutture dei dati
Alla riga 18 il dato inserito da tastiera viene assegnato all’elemento vett con indice i, dove i, grazie
al ciclo for, assume, di volta in volta, i valori che vanno da 0 a 4.
Alla riga 24 la scrittura degli elementi del vettore viene realizzata con un secondo ciclo for.
Alla riga 26 ogni elemento del vettore viene scritto sulla stessa riga dei precedenti. Solo alla fine del
ciclo for, alla riga 28, si va a capo per scrivere una nuova riga di messaggio.
...........................................................................................................................................
10.6 Array di dimensione variabile
Allo scopo di fornire all’utente strumenti flessibili, vediamo di perfezionare ulteriormente gli esempi
fin qui visti, in modo da realizzare un programma che permetta all’utente di caricare un vettore la
cui dimensione è definita dall’utente stesso. Nell’esempio del paragrafo precedente è stata data la
possibilità di caricare i dati di un array da tastiera, ma la dimensione del vettore era definita come costante
uguale a 5. Nulla vieta, però, di acquisire da tastiera la dimensione del vettore e di definire il
vettore stesso solo dopo avere avuto a disposizione la dimensione scelta dall’utente.
Esempio arrayVaria............................................................................................................
Permettere l’inserimento da tastiera dei valori di un vettore di interi. Anche la dimensione
del vettore è acquisita da tastiera e deve essere inferiore a 20.
Descrizione della soluzione
L’algoritmo e il programma che viene presentato si discostano dal precedente soltanto perché la dimensione
non è definita come costante, ma è letta da tastiera.
Pseudocodifica
//costanti
dimensione massima = 20
//struttura dati
vettore di interi
//input
dimensione
serie di n interi (n = dimensione)
//output
vettore di interi
INIZIO
leggi (dimensione)
PER ogni elemento del vettore
chiedi dato
carica dato
FINE PER
PER ogni elemento del vettore
scrivi (elemento)
FINE PER
FINE
Codice
1 #include
2 using namespace std;
arrayVaria.cpp

3
4 //INIZIO
5 int main ()
6 {
7 const int MAX = 20; //dimensione massima per il vettore
8 int dim;
9 int i;
10
11 //definisci il vettore
12 int vett[MAX];
13
14 //acquisisci e controlla la dimensione
15 do
16 {
17 coutdim;
19 }
20 //controlla il rispetto dei limiti
21 while (dim < 1 | dim > MAX);
22
23 //salta una riga
24 cout

180
Sezione 4 - Strutture dei dati
Analisi del codice
Alla riga 7 viene definita la costante intera MAX, che rappresenta la dimensione massima per il vettore.
Tale dimensione è posta pari a 20, così come richiesto dal testo del problema. Alla riga 8 è
definita la variabile dim, in cui viene memorizzata la dimensione effettiva del vettore inserita da tastiera.
Alla riga 12 viene definito il vettore di dimensione MAX, di cui verranno utilizzate soltanto le prime
dim posizioni.
Alle righe 17 e 18 viene rispettivamente richiesto e acquisito il valore di dim; le elaborazioni successive
del vettore fanno riferimento solo a questo valore, come si può vedere alle righe 26 e 35.
Alla riga 21 viene eseguito un controllo sul valore dim inserito da tastiera: soltanto se rientra tra i limiti
imposti dal problema (è cioè compreso tra 1 e MAX) l’elaborazione può procedere.
Alla riga 24 viene immessa a video una riga vuota, per separare le istruzioni di acquisizione della dimensione
dalla fase di caricamento e stampa dei dati del vettore. Tale fase è identica a quella già vista
nell’esempio ArrayCarica.
...........................................................................................................................................
10.7 Matrici
Nei paragrafi precedenti abbiamo visto come lavorare con array a una dimensione, vale a dire con array
che hanno un unico indice di individuazione degli elementi che li compongono.
È possibile, tuttavia, definire anche array a due o più dimensioni.
Solitamente, gli array a una dimensione prendono il nome di vettori, mentre gli array
a due dimensioni sono detti matrici.
Come già visto, un array a una dimensione è definito da un nome e da una dimensione, con una sintassi
del tutto simile a quella riportata di seguito.
const int dim = 4;
int vettore[dim];
Se, per esempio, è dato il vettore:
avremo che l’elemento Vettore[2] contiene il valore 11.
Per definire una matrice, invece, occorre specificare due o più dimensioni.
Una matrice è un insieme di dati dello stesso tipo organizzati in una griglia: ogni elemento
che compone la matrice è individuato dall’indice di riga e dall’indice di colonna
in cui l’elemento è posizionato.
In C++ la definizione della struttura di una matrice è analoga alla definizione di un array a una dimensione.
Per esempio, se si scrive:
int matrice[3][4]
VETTORE
Dati → 37 53 11 28
Indice → 0 1 2 3

s’intende che la struttura di nome matrice è composta da 3 righe e 4 colonne, come mostrato nell’esempio
che segue.
Per elaborare un singolo elemento della matrice occorre specificare il numero di riga e il numero di
colonna. Con riferimento alla matrice precedente, si può dire che 18 è contenuto nella cella individuata
da matrice[1][2].
Esempio MatriceCarica .....................................................................................................
Caricare i dati di una matrice di interi con numero di righe e numero di colonne non superiore
a 20. Scrivere il contenuto della matrice.
Descrizione della soluzione
Il limite di 20 è posto per non definire in memoria una struttura troppo ingombrante.
Il programma è organizzato in tre parti. La prima parte serve per acquisire il numero di righe e il numero
di colonne e per preparare la matrice.
Quando viene acquisito il numero di righe, viene controllato che questo non ecceda il limite di 20:
se ciò accade, il programma richiede di nuovo l’inserimento del dato e così succede per il numero delle
colonne.
La matrice è inizialmente definita come un array con dimensioni massime: solo dopo avere acquisito
il numero di righe e di colonne vengono definite le sue dimensioni effettive.
La seconda parte consiste nel caricamento dei dati nella matrice. Vengono utilizzati due indici: i per
le righe e j per le colonne. Per il caricamento si consideri ogni riga della matrice come un vettore e
si proceda come negli esempi del paragrafo precedente al caricamento del vettore attraverso una ripetizione
enumerativa con l’indice j che va da 0 al numero di colonne – 1. Tale iterazione viene nidificata
in una ripetizione più esterna che ripete l’operazione di acquisizione per tutte le righe della
matrice, con l’indice i che varia da 0 al numero di righe – 1.
Per la terza e ultima parte, la stampa della matrice, di nuovo si devono organizzare due cicli for uno
interno all’altro: il più interno serve per “visitare” gli elementi di una riga mentre l’esterno serve per
ripetere tale operazione su tutte le righe. Occorre avere l’accortezza di scrivere gli elementi di una
stessa riga senza andare a capo e di andare a capo solo alla fine della riga della matrice, cioè alla fine
del ciclo for più interno.
Pseudocodifica
Righe
Costante MAX = 20 //limite massimo per le dimensioni della matrice
//struttura dati
Matrice di interi
//input
Righe
Colonne
0
1
2
7
45
11
MATRICE
37
12
53
24
18
37
0 1 2
Colonne
Unità didattica 10 - Enumerazioni e array
3
81
28
3
181

182
Sezione 4 - Strutture dei dati
Serie di numeri per caricare la matrice
//output
Matrice
//variabili di lavoro
i indice di riga
j indice di colonna
INIZIO
//acquisisci numero delle righe
RIPETI
leggi (righe)
//controlla rispetto dei limiti
MENTRE righe < 1 OR righe > 20
//acquisisci numero delle colonne
RIPETI
leggi (colonne)
//controlla rispetto dei limiti
MENTRE colonne < 1 OR colonne > 20
//carica dati nella matrice
PER i DA 0 A righe – 1
PER j DA 0 A colonne – 1
chiedi dato
carica dato
FINE PER
FINE PER
//visita la matrice
PER i DA 0 A righe – 1
PER j DA 0 A colonne – 1
scrivi (matrice [i, j])
FINE PER
vai a capo
FINE PER
FINE
Codice
MatriceCarica.cpp
1 #include
2 #include
3 using namespace std;
4
5 //INIZIO
6 int main ()
7 {
8 const int MAX = 20; //dimensione massima per la matrice
9
10 //definisci la matrice
11 int mat[MAX][MAX];
12 int righe;
13 int colonne;

Unità didattica 10 - Enumerazioni e array
14 int i;
15 int j;
16
17 //acquisisci numero delle righe
18 do
19 {
20 cout

184
Sezione 4 - Strutture dei dati
Prova di esecuzione
Analisi del codice
Alla riga 11 viene definita la struttura della matrice, che viene identificata con il nome mat e per la
quale è specificato il numero delle righe e delle colonne.
Alle righe 20 e 21 viene acquisito il numero di righe che compongono la matrice; le istruzioni di acquisizione
sono inserite all’interno di una ripetizione che serve per controllare se il numero digitato
rientra nei limiti imposti (da 1 a 20).
Alle righe 29 e 30 viene definito un processo analogo per l’acquisizione del numero di colonne.
Alla riga 38 inizia il caricamento dei dati nella matrice: il primo ciclo for serve per ripetere le operazioni
sottostanti per tutte le righe.
Alla riga 40 viene definito il ciclo for più interno, che permette di “muoversi” all’interno di una riga,
e per ogni elemento della riga viene acquisito il dato da inserire come indicato alle righe 43 e 44.
In particolare, alla riga 44, il dato letto da tastiera viene assegnato a una “casella” della matrice di nome
mat individuata dai due indici i e j.
Alla riga 50 inizia la scrittura dei dati della matrice: l’impostazione generale del codice successivo è
analoga a quella precedente relativa al caricamento dei dati: la differenza principale è che, nel ciclo
for più interno, l’istruzione di scrittura indicata alla riga 56 permette di scrivere i dati uno di seguito
all’altro, mentre alla riga 59 è indicata l’istruzione per andare a capo. Tale istruzione non rientra
nel ciclo for interno, ma fa parte del ciclo for esterno, così che essa venga eseguita solo alla fine di
ogni riga e venga ripetuta per ogni riga.
...........................................................................................................................................
Allo scopo di acquisire dimestichezza con i problemi relativi al trattamento delle matrici, viene presentato
un secondo esempio.
Esempio TotaleRighe..........................................................................................................
Caricare i dati di una matrice di interi con numero di righe e numero di colonne non superiore
a 20. Scrivere il contenuto della matrice e indicare per ogni riga il totale dei valori in
essa contenuti.
Descrizione della soluzione
La prima parte della richiesta del problema è identica a quella dell’esempio precedente; si tratta solo
di intervenire nella parte relativa alla visualizzazione del contenuto della matrice e inserire in questa
parte le istruzioni per comunicare i totali di riga.

Si definisca una variabile totRiga in cui accumulare i valori di ciascuna riga e, con riferimento al
segmento di codice relativo alla scrittura della matrice, si inseriscano le istruzioni che servono per:
1. inizializzare totRiga;
2. sommare in totRiga i valori di una riga della matrice;
3. scrivere totRiga.
Pseudocodifica
Costante Max = 20 //limite massimo per le dimensioni della matrice
//struttura dati
matrice di interi
//input
Righe
Colonne
Serie di numeri per caricare la matrice
//output
matrice
totaleRiga
//variabili di lavoro
i indice di riga
j indice di colonna
INIZIO
. . . .
//parte uguale all’esempio precedente
. . . .
//visita la matrice
PER i DA 0 A righe – 1
totRiga ← 0
PER j DA 0 A colonne – 1
scrivi (matrice [i, j])
totRiga ← totRiga + mat [i, j]
FINE PER
scrivi (totRiga) e vai a capo
FINE PER
FINE
Codice
TotaleRighe.cpp
1 #include
2 #include
3 using namespace std;
4
5 //INIZIO
6 int main ()
7 {
8 const int MAX = 20; //dimensione massima per la matrice
9
10 //definisci la matrice
11 int mat[MAX][MAX];
12 int righe;
Unità didattica 10 - Enumerazioni e array
185

186
Sezione 4 - Strutture dei dati
13 int colonne;
14 int i;
15 int j;
16 int totRiga;
17
18 //acquisisci numero delle righe
19 do
20 {
21 cout

68 cout

188
Sezione 4 - Strutture dei dati
Lo sviluppo top-down del programma
è illustrato nella figura a destra.
Codice
Chiedi
dimensione
funzioniArray.cpp
main
Leggi
vettore
1 #include
2 using namespace std;
3
4 const int MAX = 20; //dimensione massima per il vettore
5 int dim; //dimensione acquisita da tastiera
6 int i;
7
8 //funzione per leggere la dimensione
9 int chiediDim (int &d)
10 {
11 //acquisisci e controlla la dimensione
12 do
13 {
14 //chiedi e leggi la dimensione
15 coutd;
17 }
18 //controlla il rispetto dei limiti
19 while (d < 1 | d > MAX);
20 return d;
21 }
22
23 //funzione per leggere il vettore
24 void leggiVettore (int v[], int d)
25 {
26 for (i=0; i

46 //INIZIO
47 int main ()
48 {
49 //definisci il vettore con dimensione MAX
50 int vett[MAX];
51
52 //richiama la funzione per acquisire la dimensione del vettore
53 dim = chiediDim (dim);
54
55 //salta una riga
56 cout

190
Sezione 4 - Strutture dei dati
Esercizi
Unità didattica 10
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calcolare
la somma dei valori contenuti nel vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzerare
il primo elemento del vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzerare
l’ultimo elemento del vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzerare
l’elemento di posto n, con n dato in input.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calcolare
la media dei valori contenuti nel vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calcolare
la media dei valori contenuti nel vettore. Successivamente scrivere gli elementi del vettore che hanno
valore superiore alla media.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calcolare
la media dei valori contenuti nel vettore. Successivamente contare gli elementi del vettore che hanno
valore superiore alla media.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calcolare
la media dei valori contenuti nel vettore. Successivamente creare un nuovo vettore che contenga gli
elementi del vettore iniziale che hanno valore superiore alla media.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), scrivere
gli elementi pari contenuti nel vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), scrivere
gli elementi di posto pari contenuti nel vettore.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), creare
un nuovo vettore che contenga gli elementi pari del vettore iniziale.
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), inserire
“in testa” al vettore un nuovo elemento. Scrivere il vettore iniziale e il vettore modificato. (Suggerimenti:
poiché deve essere inserito un nuovo elemento il vettore deve essere definito con dimensione pari a
d + 1; “in testa” al vettore vuol dire al posto 0 del vettore; per fare spazio al nuovo elemento, i dati preesistenti
devono essere spostati di un posto a destra).
Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), inserire
“in coda” al vettore un nuovo elemento. Scrivere il vettore iniziale e il vettore modificato. (Suggerimenti:
poiché deve essere inserito un nuovo elemento il vettore deve essere definito con dimensione pari a d
+ 1; “In coda” al vettore vuol dire dopo l’ultimo elemento del vettore; per fare spazio al nuovo elemento,
basta aumentare la dimensione iniziale).