Sei sulla pagina 1di 30

Preliminari.

qxd 23-01-2009 12:33 Pagina 1

Cesare Rota

Programmare con C++

EDITORE ULRICO HOEPLI MILANO


Preliminari.qxd 15-01-2009 12:19 Pagina 2

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
Preliminari.qxd 15-01-2009 12:19 Pagina 3

Indice

Presentazione 5 4.2 Output formattato 58


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

3
Preliminari.qxd 15-01-2009 12:19 Pagina 4

Indice

U.D. 9 - Le funzioni 142 12.4 Ereditariet 213


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

4
Preliminari.qxd 23-01-2009 12:34 Pagina 5

Presentazione

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 programma-


zione;
: 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 og-
getti e la gestione dei file.

Il libro suddiviso in sette sezioni.

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 arit-
metici.
3 Nella sezione Organizzazione degli algoritmi viene introdotta la nozione di algorit-
mo 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 Lintera sezione Classi e oggetti dedicata alle nozioni fondamentali della OOP e
vengono presentati i concetti principali della programmazione orientata agli ogget-
ti quali lincapsulamento, il polimorfismo e lereditariet.
6 La sezione Operare con gli archivi spiega le nozioni di base per la definizione de-
gli 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
Preliminari.qxd 15-01-2009 12:19 Pagina 6

Presentazione

di facile lettura, che aiuta lo studente a concentrarsi, di volta in volta, su un singolo ele-
mento 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 lanalisi dettagliata del codice
stesso; questultima parte dellesempio presenta una descrizione dettagliata degli aspetti
pi significativi del linguaggio C++ presenti nellesempio.

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 impare-
rai a fare e Che cosa dovrai studiare. In concreto, gli obiettivi generali presentati alli-
nizio 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 compe-
tenze e le conoscenze che devono essere apprese dallalunno.

Considerando lampiezza della trattazione, il libro include tutti i contenuti dei program-
mi didattici tradizionalmente affrontati nelle classi terze degli istituti tecnici.
In particolare pu essere adottato nella classe terza degli Istituti Tecnici Industriali con in-
dirizzo ABACUS o informatica industriale, in quella degli Istituti Tecnici Commerciali
con indirizzo MERCURIO o programmatori, nonch in quella dei Licei scientifici tec-
nologici.

LAutore

6
S04UD10.qxd 15-01-2009 9:21 Pagina 167

Sezione 4
Strutture dei dati

Obiettivi
generali Definire insiemi di dati numerabili
Saper utilizzare schemi logici per organizzare insiemi
complessi di dati
Costruire tabelle di dati omogenei
Manipolare stringhe di caratteri
Raggruppare dati di tipo diverso

& Questa sezione contiene


U.D.10
U.D.11
Enumerazioni e array
Stringhe e strutture
S04UD10.qxd 15-01-2009 9:21 Pagina 168

10
Unit didattica
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
S04UD10.qxd 15-01-2009 9:21 Pagina 169

Unit didattica
Enumerazioni e array
10
10.1 Introduzione
Finora abbiamo visto i tipi di dato pi comuni e i pi facili da utilizzare in C++, cio i tipi predefini-
ti: 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 ti-
po semplice oppure aggregati in modo complesso.
I tipi di dato semplici sono classificati secondo lo schema gerarchico riportato di seguito.

semplici

reali ordinali

float double enumerativi predefiniti

int char bool

I tipi semplici possono essere float o double, oppure di tipo ordinale; i tipi ordinali possono es-
sere definiti dal programmatore attraverso i tipi enumerativi, oppure possono appartenere ai tipi or-
dinali 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 prece-
denza.

10.2 Tipi enumerativi (enumerazioni)


A volte una variabile pu assumere solo una serie di valori definiti allinterno di un insieme discreto
di possibilit. Le enumerazioni sono molto comuni nella vita di tutti i giorni: per esempio, pu esse-
re unenumerazione la lista dei controlli da eseguire sullauto prima di affrontare un viaggio: freni,
fari, gomme, olio, tergicristalli, carburante.

169
S04UD10.qxd 15-01-2009 9:21 Pagina 170

Sezione 4 - Strutture dei dati

Per definire in C++ unenumerazione si usa la seguente sintassi:


enum nome_enumerazione {elenco_enumerazioni};
dove enum la parola chiave che introduce lenumerazione.
Riprendendo la lista di esempio proposta in precedenza, si pu scrivere:

enum controlli {freni, fari, gomme, olio, tergicristalli, carburante};

Il nome dellenumerazione pu essere utilizzato per dichiarare variabili di tale tipo, in maniera ana-
loga 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 prece-
denza. Per esempio, si pu scrivere:

check = gomme;

oppure

if (check == fari) cout << controlla fari;

Si deve ricordare che a ognuno dei valori di una variabile enumerativa corrisponde il numero dordi-
ne che esso occupa allinterno della definizione dellenumerazione.

Esempio Enumera...............................................................................................................
Scrivere un programma che utilizza una variabile di tipo controlli.

Codice
Enumera.cpp
1 #include <iostream>
2 using namespace std;
3
4 //INIZIO
5 int main ()
6 {
7 //definisci l'enumerazione
8 enum controlli {freni, fari, gomme, olio, tergicristalli, carburante};
9
10 //definisci la variabile di tipo enumerativo
11 controlli check;
12
13 //assegna un valore alla variabile
14 check = gomme;
15
16 //esegui un confronto
17 if (check == gomme) cout << "controlla fari";
18
19 //scrivi il numero d'ordine del valore della variabile enumerativa
20 cout << "\nNumero d'ordine di gomme = " << check;
21

170
S04UD10.qxd 15-01-2009 9:21 Pagina 171

Unit didattica 10 - Enumerazioni e array

22 //fine programma
23 cout << "\n\nFine ";
24 system ("pause");
25 return 0;
26 }

Prova di esecuzione

Analisi del codice


Alla riga 8 viene definito il tipo enumerativo controlli.
Alla riga 11 viene introdotta la variabile check di tipo controlli e alla riga 14 le viene assegnato
un valore (scelto tra quelli definiti nellenumerazione controlli).
Alla riga 17 viene eseguito un confronto. Anche se la variabile check contiene gomme, listruzio-
ne alla riga 20 non fa comparire in output la parola gomme, ma il suo numero di posizione (par-
tendo da zero) allinterno della definizione dellenumerazione.
...........................................................................................................................................

Fino a questo momento abbiamo visto come sia possibile definire e utilizzare in C++ tipi di dati che
abbiamo definito semplici.
Se ci soffermiamo, per, a considerare qualche esempio un po pi complesso di quelli presentati fi-
no a ora ci rendiamo rapidamente conto che non affatto raro incontrare la necessit di gestire elen-
chi di dati.

Pensiamo per esempio a un elenco di invitati a una festa, alla lista degli studenti di una classe o agli
iscritti a una gara. In questi tre esempi siamo di fronte a un dato (cognome e nome) sempre dello stes-
so tipo che si ripete pi volte.

Nei prossimi paragrafi presenteremo le strutture messe a disposizione da C++ per gestire non pi da-
ti singoli, bens strutture di dati che raggruppano in ununica variabile dati diversi.

10.3 Tipo vettore


Cominciamo a esaminare le strutture che contengono dati tutti dello stesso tipo: in generale, tali
strutture prendono il nome di array e si distinguono in vettori come array a una dimensione e ma-
trici come array a due dimensioni.
La prima struttura che esaminiamo la struttura di vettore che permette di raggruppare diversi dati
dello stesso tipo e di associare un indice a ogni dato.

Un vettore un insieme ordinato di oggetti omogenei, ovvero appartenenti a un


unico tipo.
possibile accedere ai vari oggetti del vettore utilizzando il loro indice numerico.
Il numero di elementi contenuto nel vettore indicato come dimensione.

171
S04UD10.qxd 15-01-2009 9:21 Pagina 172

Sezione 4 - Strutture dei dati

Prendiamo, per esempio, lelenco degli studenti di una classe, cos come appare sul registro.

1 Abbiati Mario
2 Bonaldi Piera
3 Casati Luigi
4 Esposito Salvatore
.. ...
.. ...
24 Vivaldi Giuseppe

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 del-
lo 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.

4
3

1 2

Possiamo scrivere: E LATO MISURA


1 15
2 8
3 7
4 16

Ogni elemento dellesempio 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++


Listruzione per definire un vettore ha il seguente formato:
tipo nomeVettore [dimensione];
dove:
: 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.

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];

172
S04UD10.qxd 15-01-2009 9:21 Pagina 173

Unit didattica 10 - Enumerazioni e array

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.

Si ricordi che lintervallo dei valori possibili per lindice di un vettore parte da 0 e arri-
va fino a dimensione 1.

In base a questa regola, nellesempio dellelenco degli studenti il primo studente (Abbiati Mario)
individuato dallindice 0 e lultimo (Vivaldi Giuseppe) dallindice 23.
Quando si lavora con una variabile di tipo vettore, occorre sempre, allinterno del programma, indi-
care sia il nome della variabile sia lindice che individua la componente del vettore che vogliamo trat-
tare; per esempio, per assegnare al primo elemento del vettore la misura del primo lato, si scrive:
misure[0] = 15

Si noti che lindice 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:
VETTORE
misure 15 8 7 16
indice 0 1 2 3

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 uti-
lizza la seguente istruzione:
cout << misura terzo lato = << misure[2];

Per sommare le misure del primo e del quarto lato, si utilizza la seguente istruzione:

somma = misure[0]+ misure[3]

Spesso nasce lesigenza di accedere a tutti gli elementi di un vettore o, come si usa dire, di visitare
tutti gli elementi del vettore per poter eseguire una elaborazione su ciascuno di essi. In questo caso,
torna molto utile ricorrere alla struttura della ripetizione con contatore: attraverso di essa si utilizza
un indice che assume tutti i valori che vanno da 0 a dimensione 1 del vettore e che serve per riferir-
si a ciascun elemento.

Esempio Perimetro .............................................................................................................


Dopo avere definito e inizializzato un vettore che contenga le misure dei lati di un quadrila-
tero, visualizzare la misura del perimetro.

173
S04UD10.qxd 15-01-2009 9:21 Pagina 174

Sezione 4 - Strutture dei dati

Descrizione della soluzione


Le istruzioni per definire larray e per assegnargli i valori iniziali sono gi state viste in questo para-
grafo. Per sommare tutti i lati del quadrato si definisca un ciclo for con lindice 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 allinterno 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
scrivi (Perimetro)
FINE

Codice
Perimetro.cpp
1 #include <iostream>
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

174
S04UD10.qxd 15-01-2009 9:21 Pagina 175

Unit didattica 10 - Enumerazioni e array

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<dim; i++)
25 {
26 perim = perim + misure[i]; //somma le misure ad 1 ad 1
27 }
28
29 //scrivi perimetro
30 cout<<"Perimetro = "<<perim;
31
32 //fine programma
33 cout << "\n\nFine ";
34 system ("pause");
35 return 0;
36 }

Prova di esecuzione

Analisi del codice


Alla riga 8 viene indicata la dimensione del vettore, che in questo caso costante, e alla riga 9 viene
definita la struttura del vettore di nome misure e di dimensione dim.
Alle righe da 15 a 18 viene inizializzato il vettore misure assegnando un valore a ogni componente.
Alla riga 24 comincia la visita del vettore grazie al ciclo for (con lindice che, a partire da 0, assu-
me tutti i valori minori di dim).
Alla riga 26 la visita consiste nel sommare in perim ogni elemento del vettore misure.

Le istruzioni di inizializzazione usate nellesempio precedente possono essere sostituite da una scrittu-
ra pi compatta. Nel codice Perimetro.cpp le righe da 15 a 18 servono per assegnare i valori iniziali
alle componenti del vettore misure. Le riportiamo di seguito.
misure[0] = 15;
misure[1] = 8;
misure[2] = 7;
misure[3] = 16;
Loperazione precedente pu essere realizzata assegnando direttamente i valori delle componenti in fa-
se di definizione del vettore. Quindi le sette righe di codice
7 const int dim=4;
8 int misure[dim];

175
S04UD10.qxd 15-01-2009 9:21 Pagina 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 allinterno del codice del programma. Nellesempio che segue, viene il-
lustrato come si pu fare in modo che sia lutente 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 linserimento 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 pri-
ma contiene il blocco di istruzioni che permette di caricare i dati inseriti da tastiera in ciascun ele-
mento 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

176
S04UD10.qxd 15-01-2009 9:21 Pagina 177

Unit didattica 10 - Enumerazioni e array

Codice
arrayCarica.cpp
1 #include <iostream>
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<dim; i++)
15 {
16 //richiedi un dato
17 cout<<"Inserisci un dato ";
18 cin>>vett[i];
19 }
20
21 cout<<"\nContenuto del vettore: ";
22
23 //visita il vettore
24 for (int i=0; i<dim; i++)
25 {
26 cout<<" "<<vett[i]; //scrivi elemento di posto i
27 }
28 cout<<"\nVettore visualizzato";
29
30 //fine programma
31 cout << "\n\nFine ";
32 system ("pause");
33 return 0;
34 }

Prova di esecuzione

Analisi del codice


Alla riga 14 viene introdotto il ciclo for per il caricamento dei dati nel vettore. Lindice i definito
in modo locale rispetto allistruzione for.

177
S04UD10.qxd 15-01-2009 9:21 Pagina 178

Sezione 4 - Strutture dei dati

Alla riga 18 il dato inserito da tastiera viene assegnato allelemento vett con indice i, dove i, gra-
zie 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 allutente strumenti flessibili, vediamo di perfezionare ulteriormente gli esem-
pi fin qui visti, in modo da realizzare un programma che permetta allutente di caricare un vettore la
cui dimensione definita dallutente stesso. Nellesempio del paragrafo precedente stata data la
possibilit di caricare i dati di un array da tastiera, ma la dimensione del vettore era definita come co-
stante 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 dallutente.

Esempio arrayVaria............................................................................................................
Permettere linserimento 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


Lalgoritmo e il programma che viene presentato si discostano dal precedente soltanto perch la di-
mensione 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
arrayVaria.cpp
1 #include <iostream>
2 using namespace std;

178
S04UD10.qxd 15-01-2009 9:21 Pagina 179

Unit didattica 10 - Enumerazioni e array

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 cout<<"\nInserisci la dimensione (max = 20) "
18 cin>>dim;
19 }
20 //controlla il rispetto dei limiti
21 while (dim < 1 | dim > MAX);
22
23 //salta una riga
24 cout<<"\n";
25
26 for (i=0; i<dim; i++)
27 {
28 //richiedi un dato e caricalo nel vettore
29 cout<<"Inserisci un dato ";
30 cin>>vett[i];
31 }
32
33 cout<<"\nContenuto del vettore: ";
34 //visita il vettore
35 for (i=0; i<dim; i++)
36 {
37 cout<<" "<<vett[i];
38 }
39 cout<<"\nVettore visualizzato";
40
41 //fine programma
42 cout << "\n\nFine ";
43 system ("pause");
44 return 0;
45 }

Prova di esecuzione

179
S04UD10.qxd 15-01-2009 9:21 Pagina 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 vet-
tore. 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 ta-
stiera.
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 succes-
sive 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 li-
miti imposti dal problema ( cio compreso tra 1 e MAX) lelaborazione pu procedere.
Alla riga 24 viene immessa a video una riga vuota, per separare le istruzioni di acquisizione della di-
mensione dalla fase di caricamento e stampa dei dati del vettore. Tale fase identica a quella gi vista
nellesempio ArrayCarica.
...........................................................................................................................................

10.7 Matrici
Nei paragrafi precedenti abbiamo visto come lavorare con array a una dimensione, vale a dire con ar-
ray 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 sin-
tassi del tutto simile a quella riportata di seguito.

const int dim = 4;


int vettore[dim];

Se, per esempio, dato il vettore:

VETTORE
Dati 37 53 11 28
Indice 0 1 2 3

avremo che lelemento 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 ele-
mento che compone la matrice individuato dallindice di riga e dallindice di co-
lonna in cui lelemento posizionato.

In C++ la definizione della struttura di una matrice analoga alla definizione di un array a una di-
mensione. Per esempio, se si scrive:

int matrice[3][4]

180
S04UD10.qxd 15-01-2009 9:21 Pagina 181

Unit didattica 10 - Enumerazioni e array

sintende che la struttura di nome matrice composta da 3 righe e 4 colonne, come mostrato nel-
lesempio che segue.

MATRICE

0 7 37 24 3
Righe 1 45 12 18 81
2 11 53 37 28

0 1 2 3
Colonne

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 indivi-
duata da matrice[1][2].

Esempio MatriceCarica .....................................................................................................


Caricare i dati di una matrice di interi con numero di righe e numero di colonne non supe-
riore 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 nu-
mero 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 linserimento del dato e cos succede per il numero del-
le 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 ri-
petizione enumerativa con lindice j che va da 0 al numero di colonne 1. Tale iterazione viene ni-
dificata in una ripetizione pi esterna che ripete loperazione di acquisizione per tutte le righe della
matrice, con lindice 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 allaltro: il pi interno serve per visitare gli elementi di una riga mentre lesterno serve per
ripetere tale operazione su tutte le righe. Occorre avere laccortezza 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
Costante MAX = 20 //limite massimo per le dimensioni della matrice
//struttura dati
Matrice di interi
//input
Righe
Colonne

181
S04UD10.qxd 15-01-2009 9:21 Pagina 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 <iostream>
2 #include <iomanip>
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;

182
S04UD10.qxd 15-01-2009 9:21 Pagina 183

Unit didattica 10 - Enumerazioni e array

14 int i;
15 int j;
16
17 //acquisisci numero delle righe
18 do
19 {
20 cout<<"\nInserisci il numero righe (max="<<MAX<<") ";
21 cin>>righe;
22 }
23 //controlla il rispetto dei limiti
24 while (righe < 1 | righe > MAX);
25
26 //acquisisci numero delle colonne
27 do
28 {
29 cout<<"\nInserisci il numero colonne (max="<<MAX<<") ";
30 cin>>colonne;
31 }
32 //controlla il rispetto dei limiti
33 while (colonne < 1 | colonne > 20);
34
35 cout<<"\n";
36
37 //carica dati nella matrice
38 for (i=0; i<righe; i++) //per ogni riga della matrice
39 {
40 for (j=0; j<colonne; j++) //per ogni elemento della riga
41 {
42 //richiedi un dato e caricalo nella matrice
43 cout<<"Inserisci un dato ";
44 cin>>mat [i][j];
45 }
46 }
47
48 cout<<"\nContenuto della matrice: \n";
49 //visita la matrice
50 for (i=0; i<righe; i++) //per ogni riga della matrice
51 {
52 for (j=0; j<colonne; j++) //per ogni elemento della riga
53 {
54 //scrivi gli elementi di una riga
55 //uno di seguito all'altro, con ingombro pari a 6 caratteri
56 cout<<setw(6)<<mat[i][j];
57 }
58 //alla fine della riga va a capo
59 cout<<"\n";
60 }
61
62 cout<<"\nmatrice visualizzata";
63
64 //fine programma
65 cout << "\n\nFine ";
66 system ("pause");
67 return 0;
68 }

183
S04UD10.qxd 15-01-2009 9:21 Pagina 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 ac-
quisizione sono inserite allinterno 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 lacquisizione del numero di colonne.
Alla riga 38 inizia il caricamento dei dati nella matrice: il primo ciclo for serve per ripetere le opera-
zioni sottostanti per tutte le righe.
Alla riga 40 viene definito il ciclo for pi interno, che permette di muoversi allinterno di una ri-
ga, 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 no-
me mat individuata dai due indici i e j.
Alla riga 50 inizia la scrittura dei dati della matrice: limpostazione generale del codice successivo
analoga a quella precedente relativa al caricamento dei dati: la differenza principale che, nel ciclo
for pi interno, listruzione di scrittura indicata alla riga 56 permette di scrivere i dati uno di segui-
to allaltro, mentre alla riga 59 indicata listruzione 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 pre-
sentato un secondo esempio.

Esempio TotaleRighe..........................................................................................................
Caricare i dati di una matrice di interi con numero di righe e numero di colonne non supe-
riore 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 dellesempio 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.

184
S04UD10.qxd 15-01-2009 9:21 Pagina 185

Unit didattica 10 - Enumerazioni e array

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 allesempio 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 <iostream>
2 #include <iomanip>
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;

185
S04UD10.qxd 15-01-2009 9:21 Pagina 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<<"\nInserisci il numero righe (max="<<MAX<<") ";
22 cin>>righe;
23 }
24 //controlla il rispetto dei limiti
25 while (righe < 1 | righe > MAX);
26
27 //acquisisci il numero delle colonne
28 do
29 {
30 cout<<"\nInserisci il numero colonne (max="<<MAX<<") ";
31 cin>>colonne;
32 }
33 //controlla il rispetto dei limiti
34 while (colonne < 1 | colonne > MAX);
35
36 //salta una riga
37 cout<<"\n";
38
39 //carica la matrice
40 for (i=0; i<righe; i++) //per ogni riga della matrice
41 {
42 for (j=0; j<colonne; j++) //per ogni elemento della riga
43 {
44 //richiedi un dato e caricalo nella matrice
45 cout<<"Inserisci un dato ";
46 cin>>mat [i][j];
47 }
48 }
49
50 cout<<"\nContenuto della matrice: \n";
51 cout<<setw(14)<<"Totale"<<endl;
52
53 //visita la matrice
54 for (i=0; i<righe; i++) //per ogni riga della matrice
55 {
56 totRiga = 0;
57 for (j=0; j<colonne; j++) //per ogni elemento della riga
58 {
59 //scrivi gli elementi di una riga
60 //uno di seguito all'altro, con ingombro pari a 4 caratteri
61 cout<<setw(4)<<mat[i][j];
62
63 //accumula i valori in totRiga
64 totRiga = totRiga + mat[i][j];
65 }
66 //alla fine della riga scrivi il totale
67 //e vai a capo

186
S04UD10.qxd 15-01-2009 9:21 Pagina 187

Unit didattica 10 - Enumerazioni e array

68 cout<<setw(6)<<totRiga<<endl;
69 }
70
71 cout<<"\nMatrice visualizzata";
72
73 //fine programma
74 cout << "\n\nFine ";
75 system ("pause");
76 return 0;
77 }

Prova di esecuzione

Analisi del codice


Le righe 56 e 68 realizzano rispettivamente linizializzazione e la scrittura a video di totRiga; poi-
ch queste due operazioni devono essere fatte una volta sola per ogni riga, esse sono poste allinter-
no del ciclo for pi grande, ma allesterno del ciclo for pi interno.
Alla riga 64 indicata listruzione per totalizzare i singoli valori di ogni elemento di ogni riga, per-
tanto essa posta allinterno del ciclo for pi interno.
...........................................................................................................................................

10.8 Passaggio di un vettore come parametro a una funzione


NellUnit didattica 9 stato affrontato largomento del passaggio dei parametri dal main alla fun-
zione; in particolare, stata spiegata la differenza tra passaggio per valore e per riferimento. I para-
metri presi in considerazione erano, tuttavia, dati di tipo semplice, non dati strutturati come un vet-
tore o una matrice. Nel caso in cui i parametri da passare siano array occorre rispettare alcune parti-
colarit sintattiche, che sono oggeto di questo paragrafo.
Vediamo da subito un esempio.

Esempio funzioniArray........................................................................................................
Acquisire da tastiera un vettore di dimensione non superiore a 20 righe e stamparlo. Per la
realizzazione del programma utilizzare tre funzioni, i cui nomi sono chiediDim, leggi-
Vettore, scriviVettore.

187
S04UD10.qxd 15-01-2009 9:21 Pagina 188

Sezione 4 - Strutture dei dati

Lo sviluppo top-down del programma


illustrato nella figura a destra. E main

Chiedi Leggi Scrivi


dimensione vettore vettore

Codice
funzioniArray.cpp
1 #include <iostream>
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 cout<<"\nInserisci la dimensione ";
16 cin>>d;
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<d; i++)
27 {
28 //richiedi un dato e caricalo nel vettore
29 cout<<"Inserisci un dato ";
30 cin>>v[i];
31 }
32 }
33
34 //funzione per scrivere il vettore
35 void scriviVettore (int v[], int d)
36 {
37 cout<<"\nContenuto del vettore: ";
38 //visita il vettore
39 for (i=0; i<d; i++)
40 {
41 cout<<" "<<v[i];
42 }
43 cout<<"\nVettore visualizzato";
44 }
45

188
S04UD10.qxd 15-01-2009 9:21 Pagina 189

Unit didattica 10 - Enumerazioni e array

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<<"\n";
57
58 //richiama la funzione leggiVettore
59 leggiVettore(vett,dim);
60
61 //richiama la funzione scriviVettore
62 scriviVettore(vett,dim);
63
64 //fine programma
65 cout << "\n\nFine ";
66 system ("pause");
67 return 0;
68 }

Prova di esecuzione
Risulta del tutto uguale a quella dellesempio ArrayVaria.

Analisi del codice


Dalla riga 9 alla riga 21 sviluppata la funzione chiediDim. Si noti che nellintestazione della funzio-
ne (riga 9) il parametro d richiede il passaggio per riferimento (&d), quindi le variazioni del contenuto
della variabile d hanno effetto sulla variabile globale dim, quando questa verr passata alla funzione al-
la riga 53. Alla riga 59 viene richiamata la funzione leggiVettore, che sviluppata dalla riga 24 alla
riga 32 del codice. Si noti che alla riga 59 largomento vett non riporta n la dimensione n lindica-
zione che si tratta di unarray, e che il parametro v[] presente nellintestazione della funzione alla riga
24 si limita a ricordare, con la presenza delle parentesi quadre, che si tratta di un vettore e non di un
dato elementare; inoltre v[] non preceduto dal carattere & per richiederne il passaggio per riferi-
mento, in quanto tale modalit di passaggio di parametri in questo caso automatica.
Analoghe considerazioni valgono per la funzione scriviVettore: in particolare, da notare che
il passaggio dei parametri per riferimento indispensabile per la funzione leggiVettore, ma non
per scriviVettore.

Nel caso in cui si voglia lavorare con array a pi di una dimensione i richiami alla funzione leggiVetto-
re (che in questo caso si pu chiamare leggiMatrice) mantengono la stessa sintassi indicata nelle-
sempio, con largomento privo di dimensioni, mentre nellintestazione della funzione il parametro che si ri-
ferisce alla struttura multidimensionale DEVE contenere la specifica di tutte le dimensioni tranne la prima.
Per esempio, se si vuole lavorare sulla matrice quadrata matr di ordine MAX, per richiamare la funzione
leggiMatrice si deve scrivere listruzione che segue.
leggiMatrice(matr, . . . );
mentre lintestazione della funzione assume la forma indicata di seguito.
void scriviMatrice (int m[][MAX], . . . )

...........................................................................................................................................

189
S04UD10.qxd 15-01-2009 9:21 Pagina 190

Sezione 4 - Strutture dei dati

Esercizi
Unit didattica 10

1 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calco-
lare la somma dei valori contenuti nel vettore.

2 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzera-
re il primo elemento del vettore.

3 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzera-
re lultimo elemento del vettore.

4 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), azzera-
re lelemento di posto n, con n dato in input.

5 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calco-
lare la media dei valori contenuti nel vettore.

6 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calco-
lare la media dei valori contenuti nel vettore. Successivamente scrivere gli elementi del vettore che han-
no valore superiore alla media.

7 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calco-
lare la media dei valori contenuti nel vettore. Successivamente contare gli elementi del vettore che han-
no valore superiore alla media.

8 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), calco-
lare 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.

9 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), scrive-
re gli elementi pari contenuti nel vettore.

q0 Dopo aver caricato in memoria un vettore di interi con dimensione d (con d inserito da tastiera), scrive-
re gli elementi di posto pari contenuti nel vettore.

qa 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.

qs 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. (Suggerimen-
ti: 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 pree-
sistenti devono essere spostati di un posto a destra).

qd 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 lultimo elemento del vettore; per fare spazio al nuovo elemen-
to, basta aumentare la dimensione iniziale).

190