Programmare con C++ - HOEPLI.it · di programmazione 33 U.D. 3 - Introduzione a C++ 34 3.1 Primo...

Cesare Rota

Programmare con C++

EDITORE ULRICO HOEPLI MILANO

Preliminari.qxd 23-01-2009 12:33 Pagina 1

Copyright © Ulrico Hoepli Editore S.p.A. 2009

via Hoepli 5, 20121 Milano (Italy)

tel. +39 02 864871 – fax +39 02 8052886

e-mail [email protected]

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


3

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

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

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

Indice

4


5

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 fornisconochiare indicazioni sulle caratteristiche sintattiche del linguaggio. Per quanto riguarda lebasi teoriche sono stati messi in rilievo i fondamenti dei cinque argomenti di base per laprogrammazione: la rappresentazione dei dati, le strutture di controllo utilizzabili nellacostruzione 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 deidati.

5 L’intera sezione Classi e oggetti è dedicata alle nozioni fondamentali della OOP evengono presentati i concetti principali della programmazione orientata agli ogget-ti quali l’incapsulamento, il polimorfismo e l’ereditarietà.

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 diapplicazioni “robuste”.

Ogni sezione è suddivisa in Unità didattiche le quali contengono un numero limitato diparagrafi, la cui trattazione è, di norma, contenuta in circa due pagine. Ne risulta un testo

Presentazione


Presentazione

6

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, chemette in pratica quanto esposto. Ogni esempio contiene un listato di codice, una figurache illustra una prova di esecuzione del codice proposto e l’analisi dettagliata del codicestesso; quest’ultima parte dell’esempio presenta una descrizione dettagliata degli aspettipiù significativi del linguaggio C++ presenti nell’esempio.

Per ogni sezione sono indicati gli obiettivi generali che si vogliono raggiungere, mentrenella 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 all’i-nizio di ogni modulo descrivono le capacità che lo studente deve acquisire. Le voci “Checosa imparerai a fare” e “Che cosa dovrai studiare” indicano rispettivamente le compe-tenze e le conoscenze che devono essere apprese dall’alunno.

Considerando l’ampiezza 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 Commercialicon indirizzo MERCURIO o programmatori, nonché in quella dei Licei scientifici tec-nologici.

L’Autore


Obiettivigenerali

◊ 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

U.D.10 Enumerazioni e array

U.D.11 Stringhe e strutture

Questa sezione contiene

†

&

Strutture dati

Sezione 4Strutture dei dati

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

Unità didattica 10Enumerazioni 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 168

169

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

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.

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 all’interno di un insieme discretodi possibilità. Le enumerazioni sono molto comuni nella vita di tutti i giorni: per esempio, può esse-re un’enumerazione la lista dei controlli da eseguire sull’auto prima di affrontare un viaggio: freni,fari, gomme, olio, tergicristalli, carburante.

Il tipo ordinale si chiama così perché descrive un insieme finito e ordinato di valori,che possono essere associati a numeri interi positivi.

ordinali

enumerativi predefiniti

int char bool

float double

reali

semplici

Unità didatticaEnumerazioni e array

1010

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

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 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 d’ordi-ne che esso occupa all’interno della definizione dell’enumerazione.

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

Sezione 4 - Strutture dei dati

170

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

Unità didattica 10 - Enumerazioni e array

171

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 assegnatoun valore (scelto tra quelli definiti nell’enumerazione controlli).Alla riga 17 viene eseguito un confronto. Anche se la variabile check contiene “gomme”, l’istruzio-ne alla riga 20 non fa comparire in output la parola “gomme”, ma il suo numero di posizione (par-tendo da zero) all’interno della definizione dell’enumerazione............................................................................................................................................

Fino a questo momento abbiamo visto come sia possibile definire e utilizzare in C++ tipi di dati cheabbiamo 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 agliiscritti 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 un’unica variabile dati diversi.

10.3 Tipo vettore

Cominciamo a esaminare le strutture che contengono dati tutti dello stesso tipo: in generale, talistrutture 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 datidello stesso tipo e di associare un indice a ogni dato.

Un vettore è un insieme ordinato di oggetti omogenei, ovvero appartenenti a ununico tipo.È possibile accedere ai vari oggetti del vettore utilizzando il loro indice numerico.Il numero di elementi contenuto nel vettore è indicato come dimensione.

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

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

Possiamo scrivere: E

Ogni elemento dell’esempio precedente è un dato di tipo numerico (la misura del lato) e per ognimisura è presente un indice che è il numero del lato; la dimensione è 4.

10.4 Vettori in C++

Riprendendo gli esempi del paragrafo precedente, per definire il vettore che contiene i nomi dei 24studenti di una classe possiamo scrivere:

int dim = 24;

string Studenti [dim];

L’istruzione 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.

LATO MISURA

1 15

2 8

3 7

4 16

4

1 2

3

1 Abbiati Mario

2 Bonaldi Piera

3 Casati Luigi

4 Esposito Salvatore

.. ...

.. ...

24 Vivaldi Giuseppe


172

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

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 questomodo 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, indi-care sia il nome della variabile sia l’indice 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 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 questotipo:

Alcuni esempi di istruzioni sugli elementi di un vettoreSempre 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 l’esigenza 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 utilizzaun 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.

VETTORE

misure → 15 8 7 16

indice → 0 1 2 3

Si ricordi che l’intervallo dei valori possibili per l’indice di un vettore parte da 0 e arri-

va fino a dimensione –1.


173

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

Descrizione della soluzione

Le istruzioni per definire l’array 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 l’indice che va da 0 a 3 e chepermette di accedere a tutti e quattro i lati del quadrilatero, vale a dire a tutti e quattro gli elementidel vettore delle misure.

Pseudocodifica

//struttura dativettore delle misure dei lati//input//tutti i dati sono definiti all’interno del programma//outputperimetro//variabili di lavoroi //indice per ciclo for

INIZIO//inizializza il vettore delle misuremisure[0] ← 15misure[1] ← 8misure[2] ← 7misure[3] ← 16

//inizializza perimetroperimetro ← 0

//visita il vettorePER i DA 0 A dim – 1

perimetro = perimetro + misure[i] //somma le misure ad 1 ad 1FINE PER

scrivi (Perimetro)

FINE

Codice

Perimetro.cpp



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 174

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



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 vienedefinita 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 l’indice 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.


175

Le istruzioni di inizializzazione usate nell’esempio 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 inizialialle componenti del vettore misure. Le riportiamo di seguito.

misure[0] = 15;

misure[1] = 8;

misure[2] = 7;

misure[3] = 16;

L’operazione 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];

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

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

10.5 Caricamento di un vettore in memoria

Nel paragrafo precedente è stato illustrato un esempio di trattamento di un vettore, ipotizzando chei suoi valori fossero caricati all’interno del codice del programma. Nell’esempio che segue, viene il-lustrato come si può fare in modo che sia l’utente a caricare direttamente in un vettore i valori chedesidera. 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.


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

//costantidimensione = 5//struttura dativettore di 5 interi//inputserie di 5 numeri//outputvettore di 5 interi

INIZIOPER ogni elemento del vettore

richiedi datocarica dato

FINE PERPER ogni elemento del vettore

scrivi (elemento)FINE PER

FINE


176

. . .

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.

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

Codice

arrayCarica.cpp



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



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. L’indice i è definitoin modo “locale” rispetto all’istruzione for.


177

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

Alla riga 18 il dato inserito da tastiera viene assegnato all’elemento 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 delciclo 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 esem-pi fin qui visti, in modo da realizzare un programma che permetta all’utente di caricare un vettore lacui dimensione è definita dall’utente stesso. Nell’esempio del paragrafo precedente è stata data lapossibilità 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 ilvettore 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.


L’algoritmo e il programma che viene presentato si discostano dal precedente soltanto perché la di-mensione non è definita come costante, ma è letta da tastiera.

Pseudocodifica

//costantidimensione massima = 20//struttura dativettore di interi//inputdimensioneserie di n interi (n = dimensione)//outputvettore di interi

INIZIOleggi (dimensione)PER ogni elemento del vettore

chiedi datocarica dato

FINE PERPER ogni elemento del vettore

scrivi (elemento)FINE PER

FINE

Codice

arrayVaria.cpp




178

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

3 4 //INIZIO5 int main () 6 {7 const int MAX = 20; //dimensione massima per il vettore8 int dim;9 int i;10 11 //definisci il vettore12 int vett[MAX];13 14 //acquisisci e controlla la dimensione15 do16 {17 cout<<"\nInserisci la dimensione (max = 20) "18 cin>>dim;19 }20 //controlla il rispetto dei limiti21 while (dim < 1 | dim > MAX);22 23 //salta una riga24 cout<<"\n";25 26 for (i=0; i<dim; i++)27 {28 //richiedi un dato e caricalo nel vettore29 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 programma42 cout << "\n\nFine "; 43 system ("pause");44 return 0;45 }

Prova di esecuzione


179

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

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 primedim 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) l’elaborazione 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à vistanell’esempio 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.

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:

avremo che l’elemento Vettore[2] contiene il valore 11.

Per definire una matrice, invece, occorre specificare due o più dimensioni.

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]

Una matrice è un insieme di dati dello stesso tipo organizzati in una griglia: ogni ele-mento che compone la matrice è individuato dall’indice di riga e dall’indice di co-lonna in cui l’elemento è posizionato.

VETTORE

Dati → 37 53 11 28

Indice → 0 1 2 3

Solitamente, gli array a una dimensione prendono il nome di vettori, mentre gli arraya due dimensioni sono detti matrici.


180

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

s’intende che la struttura di nome matrice è composta da 3 righe e 4 colonne, come mostrato nel-l’esempio che segue.

Per elaborare un singolo elemento della matrice occorre specificare il numero di riga e il numero dicolonna. 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.


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 l’inserimento del dato e così succede per il numero del-le colonne. La matrice è inizialmente definita come un array con dimensioni massime: solo dopo avere acquisitoil 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 perle righe e j per le colonne. Per il caricamento si consideri ogni riga della matrice come un vettore esi proceda come negli esempi del paragrafo precedente al caricamento del vettore attraverso una ri-petizione enumerativa con l’indice j che va da 0 al numero di colonne – 1. Tale iterazione viene ni-dificata in una ripetizione più esterna che ripete l’operazione di acquisizione per tutte le righe dellamatrice, 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 unointerno all’altro: il più interno serve per “visitare” gli elementi di una riga mentre l’esterno serve perripetere tale operazione su tutte le righe. Occorre avere l’accortezza di scrivere gli elementi di unastessa riga senza andare a capo e di andare a capo solo alla fine della riga della matrice, cioè alla finedel ciclo for più interno.

Pseudocodifica

Costante MAX = 20 //limite massimo per le dimensioni della matrice//struttura datiMatrice di interi//inputRighe Colonne

0

1 Righe

2

7

45

11

37

12

53

24

37

18

3

81

28

0 1 2

Colonne

MATRICE

3


181

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

Serie di numeri per caricare la matrice//outputMatrice//variabili di lavoroi indice di rigaj indice di colonna

INIZIO//acquisisci numero delle righeRIPETI

leggi (righe)//controlla rispetto dei limiti

MENTRE righe < 1 OR righe > 20

//acquisisci numero delle colonneRIPETI

leggi (colonne)//controlla rispetto dei limiti

MENTRE colonne < 1 OR colonne > 20//carica dati nella matricePER i DA 0 A righe – 1

PER j DA 0 A colonne – 1chiedi datocarica dato

FINE PERFINE PER

//visita la matrice PER i DA 0 A righe – 1

PER j DA 0 A colonne – 1scrivi (matrice [i, j])

FINE PERvai a capo

FINE PERFINE

Codice

MatriceCarica.cpp


2 #include <iomanip>


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 182

14 int i;15 int j;16 17 //acquisisci numero delle righe18 do19 {20 cout<<"\nInserisci il numero righe (max="<<MAX<<") ";21 cin>>righe;22 }23 //controlla il rispetto dei limiti24 while (righe < 1 | righe > MAX);25 26 //acquisisci numero delle colonne27 do28 {29 cout<<"\nInserisci il numero colonne (max="<<MAX<<") ";30 cin>>colonne;31 }32 //controlla il rispetto dei limiti33 while (colonne < 1 | colonne > 20);34 35 cout<<"\n";36 37 //carica dati nella matrice38 for (i=0; i<righe; i++) //per ogni riga della matrice39 {40 for (j=0; j<colonne; j++) //per ogni elemento della riga41 {42 //richiedi un dato e caricalo nella matrice43 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 matrice51 {52 for (j=0; j<colonne; j++) //per ogni elemento della riga53 {54 //scrivi gli elementi di una riga55 //uno di seguito all'altro, con ingombro pari a 6 caratteri56 cout<<setw(6)<<mat[i][j];57 }58 //alla fine della riga va a capo59 cout<<"\n";60 }61 62 cout<<"\nmatrice visualizzata";63 64 //fine programma65 cout << "\n\nFine ";66 system ("pause");67 return 0;68 }


183

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

Prova di esecuzione

Analisi del codice

Alla riga 11 viene definita la struttura della matrice, che viene identificata con il nome mat e per laquale è 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 all’interno di una ripetizione che serve per controllare se il numero digitatorientra 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 opera-zioni sottostanti per tutte le righe. Alla riga 40 viene definito il ciclo for più interno, che permette di “muoversi” all’interno 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: l’impostazione generale del codice successivo èanaloga a quella precedente relativa al caricamento dei dati: la differenza principale è che, nel ciclofor più interno, l’istruzione di scrittura indicata alla riga 56 permette di scrivere i dati uno di segui-to all’altro, mentre alla riga 59 è indicata l’istruzione per andare a capo. Tale istruzione non rientranel ciclo for interno, ma fa parte del ciclo for esterno, così che essa venga eseguita solo alla fine diogni 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.


La prima parte della richiesta del problema è identica a quella dell’esempio precedente; si tratta solodi intervenire nella parte relativa alla visualizzazione del contenuto della matrice e inserire in questaparte le istruzioni per comunicare i totali di riga.


184

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

Si definisca una variabile totRiga in cui accumulare i valori di ciascuna riga e, con riferimento alsegmento 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 datimatrice di interi//inputRigheColonneSerie di numeri per caricare la matrice//outputmatricetotaleRiga//variabili di lavoroi indice di rigaj indice di colonna

INIZIO. . . .//parte uguale all’esempio precedente. . . .//visita la matrice PER i DA 0 A righe – 1

totRiga ← 0PER j DA 0 A colonne – 1

scrivi (matrice [i, j])totRiga ← totRiga + mat [i, j]

FINE PERscrivi (totRiga) e vai a capo

FINE PERFINE

Codice

TotaleRighe.cpp


2 #include <iomanip>


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 185

13 int colonne; 14 int i;15 int j;16 int totRiga;17 18 //acquisisci numero delle righe19 do20 {21 cout<<"\nInserisci il numero righe (max="<<MAX<<") "; 22 cin>>righe;23 }24 //controlla il rispetto dei limiti25 while (righe < 1 | righe > MAX);26 27 //acquisisci il numero delle colonne28 do29 {30 cout<<"\nInserisci il numero colonne (max="<<MAX<<") ";31 cin>>colonne;32 }33 //controlla il rispetto dei limiti34 while (colonne < 1 | colonne > MAX);35 36 //salta una riga37 cout<<"\n";38 39 //carica la matrice40 for (i=0; i<righe; i++) //per ogni riga della matrice 41 {42 for (j=0; j<colonne; j++) //per ogni elemento della riga43 {44 //richiedi un dato e caricalo nella matrice45 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 matrice55 {56 totRiga = 0;57 for (j=0; j<colonne; j++) //per ogni elemento della riga58 {59 //scrivi gli elementi di una riga60 //uno di seguito all'altro, con ingombro pari a 4 caratteri61 cout<<setw(4)<<mat[i][j]; 62 63 //accumula i valori in totRiga64 totRiga = totRiga + mat[i][j]; 65 }66 //alla fine della riga scrivi il totale67 //e vai a capo


186

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

68 cout<<setw(6)<<totRiga<<endl;

69 }

70

71 cout<<"\nMatrice visualizzata";

72

73 //fine programma



76 return 0;

77 }

Prova di esecuzione

Analisi del codice

Le righe 56 e 68 realizzano rispettivamente l’inizializzazione e la scrittura a video di totRiga; poi-ché queste due operazioni devono essere fatte una volta sola per ogni riga, esse sono poste all’inter-no del ciclo for più grande, ma all’esterno del ciclo for più interno.Alla riga 64 è indicata l’istruzione per totalizzare i singoli valori di ogni elemento di ogni riga, per-tanto essa è posta all’interno del ciclo for più interno............................................................................................................................................

10.8 Passaggio di un vettore come parametro a una funzione

Nell’Unità didattica 9 è stato affrontato l’argomento 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 187

Lo sviluppo top-down del programmaè illustrato nella figura a destra. E

Codice

funzioniArray.cpp

1 #include <iostream>2 using namespace std;3 4 const int MAX = 20; //dimensione massima per il vettore5 int dim; //dimensione acquisita da tastiera6 int i;7 8 //funzione per leggere la dimensione9 int chiediDim (int &d)10 {11 //acquisisci e controlla la dimensione12 do13 {14 //chiedi e leggi la dimensione15 cout<<"\nInserisci la dimensione "; 16 cin>>d; 17 }18 //controlla il rispetto dei limiti19 while (d < 1 | d > MAX); 20 return d;21 }22 23 //funzione per leggere il vettore24 void leggiVettore (int v[], int d)25 {26 for (i=0; i<d; i++)27 {28 //richiedi un dato e caricalo nel vettore29 cout<<"Inserisci un dato "; 30 cin>>v[i];31 }32 }33 34 //funzione per scrivere il vettore35 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

main

Leggi

vettore

Chiedi

dimensione

Scrivi

vettore


188

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

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



67 return 0;

68 }

Prova di esecuzione

Risulta del tutto uguale a quella dell’esempio ArrayVaria.

Analisi del codice

Dalla riga 9 alla riga 21 è sviluppata la funzione chiediDim. Si noti che nell’intestazione della funzio-ne (riga 9) il parametro d richiede il passaggio per riferimento (&d), quindi le variazioni del contenutodella 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 allariga 32 del codice. Si noti che alla riga 59 l’argomento vett non riporta né la dimensione né l’indica-zione che si tratta di un’array, e che il parametro v[] presente nell’intestazione della funzione alla riga24 si limita a “ricordare”, con la presenza delle parentesi quadre, che si tratta di un vettore e non di undato 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 cheil passaggio dei parametri per riferimento è indispensabile per la funzione leggiVettore, ma nonper scriviVettore.

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


189

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 nell’e-sempio, con l’argomento privo di dimensioni, mentre nell’intestazione 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 funzioneleggiMatrice si deve scrivere l’istruzione che segue.

leggiMatrice(matr, . . . );

mentre l’intestazione della funzione assume la forma indicata di seguito.

void scriviMatrice (int m[][MAX], . . . )

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

190


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.


re l’ultimo elemento del vettore.


re l’elemento di posto n, con n dato in input.


lare la media dei valori contenuti nel vettore.


lare la media dei valori contenuti nel vettore. Successivamente scrivere gli elementi del vettore che han-

no valore superiore alla media.


lare la media dei valori contenuti nel vettore. Successivamente contare gli elementi del vettore che han-

no valore superiore alla media.


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 l’ultimo elemento del vettore; per fare spazio al nuovo elemen-

to, basta aumentare la dimensione iniziale).

Esercizi

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

Programmare con C++ - HOEPLI.it · di programmazione 33 U.D. 3 - Introduzione a C++ 34 3.1 Primo...

Documents

Transcript of Programmare con C++ - HOEPLI.it · di programmazione 33 U.D. 3 - Introduzione a C++ 34 3.1 Primo...