C / C++ - SourceForgegnurantudoc.sourceforge.net/linux/myCpp/myCpp.pdfC / C++ myCpp [ Stefano...

C / C++

myCpp [ Stefano Sangalli ]

Lo standard C e un linguaggio di programmazione ideato nel 1970 da Ken Thompson e Dennis Ritchieper l’utilizzo in ambiente UNIX. Negli anni ’80 B. Stroupstrup lavoro sulla struttura del Linguaggio diprogrammazione ad alto livello chiamato C, adattandolo ad una Interfaccia Grafica (GUI). Questo nuovoLinguaggio fu definito C++. In seguito si e diffuso il suo utilizzo all’interno di tutti i sistemi operativi, edora e uno dei linguaggi piu utilizzati in senso assoluto. Il C++ presenta i seguenti indubbi vantaggi:

• E’ uno standard tra i piu diffusi: questo vuol dire che sono gia disponibili una quantita notevole dilibrerie, codice gia pronto, driver di periferiche, bibliografia, compilatori, ecc...

• E’ uno dei piu flessibili: con il C++ si puo scrivere praticamente qualsiasi software, dal sistemaoperativo (auguri...) alla piccola applicazione che in 10 righe di codice toglie un sacco di lavoroquotidiano al sig. Rossi;

• Deriva dal C e quindi e perfettamente in grado di compilare il codice C, cosa che significa una ulterioreestensione della compatibilita anche con codice vecchio che non deve essere riscritto;

• Essendo uno dei linguaggi piu conosciuti e usati dai programmatori, ha dei compilatori molto affidabili ei programmi che ne risultano sono stabili (sempre che siano scritti correttamente) e veloci in esecuzionesu tutte le piattaforme;

• E’ un buon compromesso fra semplicita di scrittura del codice, potenza e flessibilita.

Scarica la VERSIONE PDF di questo documento.

Contents

1 Compilazione 5

1.1 g++ (anche Windows) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2 gcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.3 qmake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.4 Estensioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Variabili 6

2.1 Parole chiave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Tipi di dato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 Dichiarazione delle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4 Inizializzazione delle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.5 Scope e lifetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

CONTENTS 2

3 Costanti 10

3.1 Costanti letterali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.1.1 Numeri Interi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.1.2 Numeri in virgola mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.1.3 Caratteri e stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.1.4 Codici di escape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2 Costanti definite (#define) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.3 Costanti dichiarate (const) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Operatori 12

4.1 Assegnamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.2 Operatori aritmetici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.3 Operatori di assegnamento composti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.4 Incremento e decremento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.5 Operatori relazionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.6 Operatori logici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.7 Operatore condizionale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.8 Operatori bit a bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.9 Operatori espliciti di conversione di tipo (casting) . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.10 Operatore sizeof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.11 Sommario degli operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

5 Comunicazione da Console 17

5.1 Ouptut (cout) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

5.2 Input (cin) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

6 Strutture di controllo e funzioni 19

6.1 Strutture di controllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.1.1 Strutture condizionali: if ed else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.1.2 Istruzioni iterative o cicli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.1.3 Biforcazioni di controllo e salti. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.1.4 L’istruzione di scelta: switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6.2 Funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6.2.1 Funzioni senza risultato. L’uso di void. . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.2.2 Parametri passati per valore e per riferimento. . . . . . . . . . . . . . . . . . . . . . . 24

CONTENTS 3

6.2.3 Valori di default per i parametri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

6.2.4 Funzioni sovraccaricate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.2.5 Ricorrenza. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.2.6 Prototipi di funzioni. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

7 Strutture dati 27

7.1 Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

7.1.1 Inizializzazione degli Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7.1.2 Accesso ai valori di un Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7.1.3 Array multidimensionali. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7.1.4 Array come parametri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7.2 Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

7.3 Stringhe di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

7.3.1 Inizializzazione delle stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

7.3.2 Assegnazione di valori alle stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

7.4 Strutture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

7.4.1 Strutture dati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

7.4.2 Strutture annidate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

7.5 Tipi definiti dall’utente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

7.5.1 Definizione di propri tipi (typedef). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

7.5.2 Unioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

7.5.3 Unioni anonime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

7.5.4 Enumerazioni (enum) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

8 Puntatori e reference 35

8.1 I Puntatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

8.2 Operazioni sui puntatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

8.3 Puntatori vs Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

8.4 Uso dei puntatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

8.5 I reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

8.6 Uso dei reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

8.7 Puntatori vs Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

9 Programmazione a oggetti 40

9.1 Strutture e campi funzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

CONTENTS 4

9.2 Sintassi della classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

9.3 Definizione delle funzioni membro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

9.4 Costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.5 Distruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.6 Membri static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.7 Membri const e mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.8 Costanti vere dentro le classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.9 Membri volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9.10 Dichiarazioni friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

10 File Handling 41

10.1 Esempio: Salvare una stringa in un file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

10.2 Esempio: Leggere una stringa da un file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

11 Database handling 43

12 Esercizi di base 43

12.1 Scrive un testo sul monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

12.2 Contatore con ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

12.3 Contatore con ciclo While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

12.4 Contatore che indica da quanti caratteri e composta una stringa . . . . . . . . . . . . . . . . 44

12.5 Programma che calcola il massimo e il minimo in una successione di interi . . . . . . . . . . . 44

12.6 Programma che calcola perimetro e area di un triangolo di cui si conoscono le misure dei lati 45

12.7 Calcolo di decine, centinaia, migliaia di un numero fornito in input . . . . . . . . . . . . . . . 45

12.8 Lettura di un file di testo presente su disco fisso . . . . . . . . . . . . . . . . . . . . . . . . . . 46

12.9 Scrittura su file di una stringa di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

12.10Semplice programma sull’utilizzo del tipo enum . . . . . . . . . . . . . . . . . . . . . . . . . . 46

12.11Programma che permette di calcolare il numero di righe e caratteri di un testo fornito in input 47

12.12Elevamento a potenza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

12.13Programma per la verifica dei numeri primi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

12.14Conversione da numero decimale a frazione corrispondente . . . . . . . . . . . . . . . . . . . . 48

12.15Semplice calcolatrice con possibilita di eseguire calcoli consecutivi . . . . . . . . . . . . . . . . 48

13 QT [ Trolltech ] 49

13.1 Tutorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

1. Compilazione 5

1 Compilazione

Il comando gcc, GNU Compiler Collection, fa parte del progetto GNU (web server www.gnu.org). Il progettoGNU fu lanciato nel 1984 da Richard Stallman con lo scopo di sviluppare un sistema operativo di tipo Unixche fosse completamente "free" software.

g++ e’ uno script che chiama gcc con opzioni specifiche per riconoscere il C++.

gcc e g++ processano file di input attraverso uno o piu’ dei seguenti passi:

1. preprocessing rimozione dei commenti

interpretazioni di speciali direttive per il preprocessore denotate da "#" come:

#include - include il contenuto di un determinato file, Es. #include<math.h>

#define -definisce un nome simbolico o una variabile, Es. #define MAX ARRAY SIZE 100

2. compilation traduzione del codice sorgente ricevuto dal preprocessore in codice assembly

3. assembly creazione del codice oggetto

4. linking combinazione delle funzioni definite in altri file sorgenti o definite in librerie con la funzionemain() per creare il file eseguibile.

1.1 g++ (anche Windows)

# g++ -o hello hello.cpp

Richiama il compilatore g++ per compilare il programma scritto nel file hello.cpp. Il risultato viene scrittonel file eseguibile hello Per Windows sara:

# g++ -o hello.exe hello.cpp

1.2 gcc

# gcc -o hello hello.cpp

Richiama il compilatore gcc per compilare il programma scritto nel file hello.cpp. Il risultato viene scrittonel file eseguibile hello.

1.3 qmake

qmake e il pre-compilatore della Trolltech (QT).

Per creare un file di progetto lanciare all’interno della cartella con le sorgenti il comando:

# qmake -project

Per creare il Makefile di un progetto (chiamato ad esempio hello.pro):

2. Variabili 6

# qmake -o Makefile hello.pro

# make

A questo punto viene creato il file eseguibile hello

Esempio file di progetto hello.pro:

CONFIG += qt debug

HEADERS += hello.h

SOURCES += hello.cpp

SOURCES += main.cpp

In Windows invece verrebbe creata una cartella ’release’ che conterrebbe hello.exe

1.4 Estensioni

Alcuni suffissi di moduli implicati nel processo di compilazione:

• .c modulo sorgente C; da preprocessare, compilare e assemblare

• .cc modulo sorgente C++; da preprocessare, compilare e assemblare

• .cpp modulo sorgente C++; da preprocessare, compilare e assemblare

• .h modulo per il preprocessore; di solito non nominato nella riga di commando

• .o modulo oggetto; da passare linker

• .a sono librerie statiche

• .so sono librerie dinamiche

2 Variabili

Possiamo definire una variabile come una porzione di memoria in cui memorizzare un valore. Ogni variabilenecessita di un identificatore (un nome) che la distingue da ogni altra variabile. Il calcolatore riservera peressa un’area di memoria in base la tipo di dato.

2.1 Parole chiave

Il nome di una variabile (identificatore), deve essere diverso dalle parole chiave:

asm, auto, bool, break, case, catch, char, class, const, const cast, continue, default, delete, do,double, dynamic cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int,long, mutable, namespace, new, operator, private, protected, public, register, reinterpret cast,return, short, signed, sizeof, static, static cast, struct, switch, template, this, throw, true, try,typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar t

inoltre deve essere diverso anche dal nome degli operatori:

2. Variabili 7

and, and eq, bitand, bitor, compl, not, not eq, or, or eq, xor, xor eq

N.B.Alcuni compilatori che generano codice a 16bit (quali alcuni compilatori per DOS) includono anche leparole far, huge e neartra le parole chiave.

2.2 Tipi di dato

In C i tipi di dati sono 5:

• void : associabile a nessun tipo di dato;

• int : intero;

• float : numero a virgola mobile;

• double : numero a virgola mobile con doppia precisione;

• char : carattere;

In C++ sono definiti due tipi in piu:

• bool : valore booleano (true o false);

• wchar t :carattere largo (stringa);

I tipi di dato numerico possono essere modificati utilizzando:

• signed;

• unsigned;

• short;

• long;

Riassumendo, e quindi possibile avere una lista completa dei tipi di dato disponibili in C/C++:

• bool

• char

• unsigned char

• signed char

• int

• unsigned int

• signed int

• short int

• unsigned short int

2. Variabili 8

• signed short int

• long int

• signed long int

• unsigned long int

• float

• double

• long double

• wchar t

2.3 Dichiarazione delle variabili

Prima di usare una variabile occorre dichiararla specificando a quale tipo di dato essa appartenga. La sintassidi una dichiarazione di variabile prevede prima il nome del tipo di dato (quale int , short , float ...) seguitodall’identificatore scelto per denotare tale variabile. Ad esempio:

int a; float numero;

int a, b, c;

unsigned short NumeroDiFigli;

signed int IlMioSaldoBancario;

I tipi di dato interi (char, short , long e int ) possono essere signed o unsigned a seconda del rango di numeriche si vuole considerare. Quindi per specificare un intero possiamo mettere una delle parole chiave signed ounsigned prima del nome del tipo.

N.B. Se non si specifica ne signed ne unsigned viene assunto signed

2.4 Inizializzazione delle variabili

Quando dichiariamo una variabile il suo valore e indeterminato (i bit della zona di memoria riservata allavariabile hanno il valore che era stato loro assegnato da qualche precedente programma). Potremmo volereche una variabile abbia un valore particolare fin dal momento in cui viene dichiarata. Per fare questo bastaaggiungere alla dichiarazione un simbolo di uguale seguito dal valore desiderato:

tipo identificatore = valore_iniziale ;

Ad esempio se vogliamo dichiarare una variabile a di tipo int con valore iniziale 0 possiamo scrivere:

int a = 0;

Oltre a questo modo di inizializzare variabili (noto come stile C), vi e un altro modo di inizializzare levariabili piu consono allo stile C++: racchiudendo il valore iniziale tra parentesi tonde

tipo identificatore(valore_iniziale );

2. Variabili 9

Ad esempio:

int a(0);

Il C++ accetta entrambe le notazioni.

N.B. Tutte le variabili che vogliamo usare devono essere preventivamente dichiarate. Una differenza impor-tante tra C e C++ e che in C++ possiamo dichiarare delle variabili in ogni punto del programma, anche tradue istruzioni eseguibili, e non solo all’inizio di un blocco di istruzioni come e richiesto in C.

Resta comunque normalmente preferibile seguire le indicazioni del C per dichiarare le variabili in quanto ecomodo, durante la fase di correzione del programma (debugging), avere le dichiarazioni raggruppate assieme:all’inizio di ogni funzione (per le variabili locali) o direttamente nel corpo del programma al di fuori di ognifunzione (variabili globali).

2.5 Scope e lifetime

La dichiarazione di una variabile o di un qualsiasi altro identificatore si estende dal punto immediatamentesuccessivo la dichiarazione (e prima dell’eventuale inizializzazione) fino alla fine del blocco di istruzioni incui e‘ inserita (un blocco di istruzioni e‘ racchiuso sempre tra una coppia di parentesi graffe)

Una dichiarazione eseguita fuori da ogni blocco introduce un identificatore globale a cui ci si puo‘ riferireanche con la notazione ::<ID>. Ad esempio:

int X = 4; // dichiarazione esterna ad ogni blocco

int main(int, char* []) {

int X = -5, y = 0;

/* ... */

y = ::X; // a y viene assegnato 4

y = X; // assegna il valore -5

return 0;

}

L’operatore :: e‘ detto risolutore di scope e, utilizzato nel modo appena visto, permette di riferirsi alladichiarazione globale di un identificatore.

Ogni variabile oltre a possedere uno scope, ha anche un propria durata (lifetime), viene creata subitodopo la dichiarazione (e prima dell’inizializzazione!) e viene distrutta alla fine del blocco dove e‘ postala dichiarazione; fanno eccezione le variabili globali che vengono distrutte alla fine dell’esecuzione del pro-gramma. Da cio‘ si deduce che le variabili locali (ovvero quelle dichiarate all’interno di un blocco) vengonocreate ogni volta che si giunge alla dichiarazione, e distrutte ogni volta che si esce dal blocco; e‘ tuttaviapossibile evitare che una variabile locale (dette anche automatiche) venga distrutta all’uscita dal bloccofacendo precedere la dichiarazione dalla keyword static:

void func() {

int x = 5; // x e‘ creata e distrutta ogni volta

static int c = 3; // c si comporta in modo diverso e non viene distrutta

// una volta finito il blocco di istruzioni dalla funzione

/* ... */

}

3. Costanti 10

3 Costanti

Una costante e una qualsiasi espressione che ha un valore prefissato.

3.1 Costanti letterali

Le costanti si possono suddividere inNumeri Interi , Numeri in Virgola Mobile, Caratteri e Stringhe.

3.1.1 Numeri Interi

Oltre ai numeri in notazione decimale (quella comunemente usata) il C++ accetta anche letterali che deno-tano numeri interi ottali (base 8) e numeri interi esadecimali (base 16). Per scrivere un numero in notazioneottale basta premettere il carattere 0 (carattere zero) e per scrivere un numero in notazione esadecimaleoccorre premettere i due caratteri 0x (zero e x). Ad esempio i seguenti letterali sono equivalenti:

75 // decimale

0113 // ottale

0x4b // esadecimale

Essi denotano lo stesso numero: 75 (settantacinque) espresso rispettivamente come numero in base 10, inbase 8 e in base 16.

3.1.2 Numeri in virgola mobile

Sono numeri con una parte frazionaria e/o un fattore esponenziale. Sono rappresentati con letterali in cuicompare il punto decimale che separa la parte intera dalla parte decimale (noi usiamo la virgola ma neipaesi anglosassoni si usa il punto) e/o un carattere e seguito da un esponente intero (che si legge "per 10alla X, dove X e l’intero che segue il carattere e").

3.14159 // 3.14159

6.02e23 // 6.02 x 10 elevato alla 23

1.6e-19 // 1.6 x 10 elevato alla 19

3.0 // 3.0

sono tutti letterali che rappresentano numeri in virgola mobile.

3.1.3 Caratteri e stringhe

Vi sono anche dei letterali che rappresentano costanti non numeriche:

’z’

’p’

"Salve gente"

"Come state?"

3. Costanti 11

I primi due rappresentano un singolo carattere mentre gli altri due rappresentano stringhe di diversi caratteri.Osserviamo che i letterali che rappresentano singoli caratteri sono racchiusi tra due caratteri apice (’ ) mentrei letterali che rappresentano stringhe sono racchiusi tra due caratteri doppio apice ("). Questo e necessarioper poter distinguere valori di tipo stringa da valori di tipo carattere (che sono considerati diversi). Inoltre,l’uso degli apici ( ’ ) e ( " ) evita di confondere un letterale carattere o stringa da un identificatore o unaparola chiave. Infatti in:

x

’x’

x denota la variabile x, mentre ’x’ denota la costante di tipo carattere ’x’ .

3.1.4 Codici di escape

Per rappresentare con un letterale (o all’interno di un letterale stringa) alcuni caratteri speciale si usanonotazioni particolari (i codici di escape). Ecco una lista di tali codici di escape (ognuno di essi inizia con ilcarattere barra rovesciata (\):

\n a capo riga

\r ritorno carrello

\t tabulazione

\v tabulazione verticale

\b backspace

\f nuova pagina

\a allerta (beep)

\’ apice singolo (’ )

\" doppio apice (" )

\? punto interrogativo ( ?)

\\ barra rovesciata ( \ )

Possiamo inoltre rappresentare ogni carattere del codice ASCII usando il suo codice numerico in ottalepreceduto da una sbarra rovesciata (\) oppure il suo codice numerico in esadecimale preceduto da unasbarra rovesciata e un carattere x ( \x ). Ad esempio \23 e \37 rappresentano i caratteri ASCII di codice19 e 31 mentre, usando la notazione esadecimale, i medesimi due caratteri si denotano con \x13 e \x1f.

3.2 Costanti definite (#define)

Possiamo usare la direttiva #define del preprocessore per dare un nome ad una costante nel seguente modo:

#define identificatore_di_costante

Ovunque useremo l’identificatore, il preprocessore provvedera a sostituirlo con la costante. Ad esempio

#define PI 3.14159265

#define NEWLINE ’\n’

#define WIDTH 100

4. Operatori 12

Questo ci evita di dover riscrivere la stessa costante piu volte in posti diversi del programma con la possibilitadi commettere errori quali scrivere in qualche posto 3.14159365 invece di 3.14159265. Una volta che abbiamoassociato un identificatore ad una costante possiamo usare tale identificatore in ogni punto seguente delprogramma come se esso fosse una costante. Ad esempio:

circonferenza = 2 * PI * r;

cout << NEWLINE;

La direttiva #define non e una istruzione C++ ma una direttiva per il preprocessore. Essa deve quindiessere scritta in una sua propria riga e non deve essere aggiunto il carattere punto e virgola (;) allafine.

3.3 Costanti dichiarate (const)

Usando il prefisso const si possono dichiarare delle costanti appartenenti ad un determinato tipo esattamenteallo stesso modo in cui si dichiarano le variabili:

const int larghezza = 100;

const char tab = ’\t’;

const int cap = 12440;

In realta le costanti dichiarate sono semplicemente delle variabili il cui valore non puo piu essere modificato(il compilatore controlla che in nessun punto del programma compaia una assegnazione o una qualsiasi altraistruzione che puo modificare il valore di una costante e in tal caso segnala un errore). Naturalmente, siccomeuna volta create non e piu possibile cambiarne il valore, esse devono essere sempre inizializzate conun valore al momento della loro creazione.

4 Operatori

Una volta appreso dell’esistenza delle variabili e delle costanti possiamo iniziare ad operare con esse. Aquesto scopo il C++ fornisce degli operatori, che nel nostro linguaggio sono un insieme di parole chiave esimboli speciali. E’ importante conoscerli perche essi sono la base del linguaggio C++.

4.1 Assegnamento

(=)

a = 5;

assegna il valore intero 5 alla variabile a . La parte alla sinistra dell’operatore = e nota come lvalue (left value)e la parte destra rvalue (right value). lvalue deve essere sempre una variabile mentre rvalue puo essere unacostante, una variabile, il risultato di un’operazione o una qualsiasi combinazione di essi. Possiamo pensarel’lvalue di a come l’indirizzo della zona di memoria riservata per memorizzare il valore di a mentre l’rvaluedi b lo dobbiamo pensare come il valore memorizzato nella zona di memoria riservata per memorizzare ilvalore di b.

4. Operatori 13

4.2 Operatori aritmetici

( +, -, *, /, % )

I cinque operatori aritmetici previsti dal linguaggio sono:

• + somma

• - differenza

• * moltiplicazione

• / divisione

• % modulo (o resto)

Gli operatori di somma, differenza, moltiplicazione e divisione eseguono le usuali quattro operazioni matem-atiche. L’operatore di modulo fornisce il resto della divisione di due numeri interi.

4.3 Operatori di assegnamento composti

( +=, -=, *=, /=, %=, >>=, <<=, &=, ˆ=, |= )

Gli operatori di assegnamento composti sono una caratteristica del C++ che contribuisce alla sua famadi essere un linguaggio sintetico. Essi permettono di modificare il valore di una variabile con una solaoperazione:

valore += incremento; // e equivalente a valore = valore + incremento;

a -= 5; // e equivalente ad a = a - 5;

a /= b; //e equivalente ad a = a / b;

prezzo *= numero + 1; // e equivalente a prezzo = prezzo * (numero + 1);

e analogamente per le altre operazioni.

4.4 Incremento e decremento

(++,–)

Un altro esempio di sinteticita si ha con gli operatori di incremento (++) e di decremento (–). Essi aumentanoo diminuiscono di 1 il valore di una variabile e sono equivalenti a += 1 e -= 1 rispettivamente. Quindi:

a++;

a += 1;

a = a+1;

fanno la stessa cosa: aumentano di 1 il valore di a.

Esempio 1 B = 3; A = ++B; // A e 4, B e 4

4. Operatori 14

Esempio2 B = 3; A = B++; // A e 3, B e 4

4.5 Operatori relazionali

( ==, !=, >, <, >=, <= )

Per confrontare i valori di due espressioni si usano gli operatori relazionali. Come specificato dallo standardANSI-C++, il risultato di un operatore relazionale e di tipo bool e puo assumere soltanto uno dei due valoribooleani true o false, a seconda del risultato del confronto.

Ecco la lista degli operatori relazionali del C++:

• == Uguale

• != Diverso

• > Maggiore

• < Minore

• >= Maggiore o uguale

• <= Minore o uguale

Attenzione! L’operatore = (un solo uguale) e differente dal simbolo == (doppio uguale), il primo el’operatore di assegnamento (assegna il valore dell’espressione alla sua destra alla variabile alla sua sinistrae ritorna tale valore) mentre il secondo e l’operatore relazionale di uguaglianza che confronta i valori delledue espressioni che stanno ai suoi lati e ritorna il valore booleano true o false a seconda che esse abbiano lostesso valore o valori diversi.

N.B. In molti compilatori precedenti la pubblicazione dello standard ANSI-C++, come pure in C, gli operatorirelazionali non ritornano un valore bool (true o false ) ma ritornano un valore int con 0 che rappresenta"false" e un valore diverso da 0 (in genere 1 ) che rappresenta "true".

4.6 Operatori logici

( !, &&, || )

• ! NOT: Operatore di negazione

• && AND: Operatore di congiunzione

• || OR: Operatore di disgiunzione

4.7 Operatore condizionale

(?)

L’operatore condizionale valuta una espressione booleana e ritorna un valore diverso a seconda che tale valoresia true oppure false. La sua forma e:

4. Operatori 15

condizione ? risultato1 : risultato2

1. se condizione e true l’espressione ritorna risultato1

2. se condizione e false l’espressione ritorna risultato2

4.8 Operatori bit a bit

( &, |, ˆ, ˜, <<, >> )

Gli operatori bit a bit operano in parallelo su tutti i bit degli operandi. Essi sono operatori di basso livelloa cui corrispondono alcune operazioni assembler. Nella programmazione normale C++ essi non dovrebberoessere usati.

• & (AND) AND bit a bit

• | (OR) OR bit a bit

• ˆ (XOR) OR esclusivo bit a bit

• ˜ (NOT) NOT bit a bit (complemento a uno)

• << (SHL) Spostamento dei bit (shift) a sinistra

• >> (SHR) Spostamento dei bit (shift) a destra

4.9 Operatori espliciti di conversione di tipo (casting)

int i;

float f = 3.14;

i = (int) f;

Il codice precedente converte il numero float 3.14 nel valore intero 3. L’operatore di conversione e rap-presentato da (int). Un modo piu consono allo stile C++ e quello di usare la funzione costruttore: farprecedere l’espressione da convertire, racchiusa tra parentesi, dal nome del nuovo tipo.

i = int ( f );

Entrambe le forme sono accettate dallo standard ANSI-C++ che inoltre ha aggiunto altri tipi di conversioneadatti alla programmazione ad oggetti.

4.10 Operatore sizeof()

Questo operatore ha un parametro che puo essere sia il nome di un tipo che una espressione. Esso ritorna lamemoria, in byte, necessaria a memorizzare un valore di tale tipo o il valore dell’espressione:

a = sizeof (char);

ritorna 1 in a perche un valore di tipo char occupa un byte. Il valore ritornato da e una costante. Esso equindi determinato a tempo di compilazione (prima dell’esecuzione del programma).

4. Operatori 16

4.11 Sommario degli operatori

Vedremo nel seguito qualche altro operatore particolare, ad esempio quelli che operano sui puntatori e quellispecifici per la programmazione ad oggetti. Essi verranno trattati nelle rispettive sezioni.

:: risolutore di scope (punta una variabile globale)

. selettore di campi

-> selettore di campi

[ ] sottoscrizione

( ) chiamata di funzione

( ) costruttore di valori

++ post incremento

-- post decremento

sizeof dimensione di

++ pre incremento

-- pre decremento

~ complemento

! negazione

- meno unario

+ piu unario

& indirizzo di

* dereferenziazione (il valore contenuto da un puntatore)

new allocatore di oggetti

new[] allocatore di array

delete deallocatore di oggetti

delete[] deallocatore di array

() conversione di tipo

.* selettore di campi

->* selecttore di campi

* moltiplicazione

/ divisione

% modulo (resto)

+ somma

- sottrazione

<< shift a sinistra

>> shift a destra

< minore

<= minore o uguale

> maggiore

>= maggiore o uguale

== uguale a

!= diverso da

& AND di bit

5. Comunicazione da Console 17

^ OR ESCLUSIVO di bit

| OR INCLUSIVO di bit

&& AND logico

|| OR logico (inclusivo)

?: espressione condizionale

= assegnamento semplice

*= moltiplica e assegna

/= divide e assegna

%= modulo e assegna

+= somma e assegna

-= sottrae e assegna

<<= shift sinistro e assegna

>>= shift destro e assegna

&= AND e assegna

|= OR inclusivo e assegna

^= OR esclusivo e assegna

throw lancio di eccezioni

, virgola

5 Comunicazione da Console

Nalla libreria standard iostream del C++ le operazioni di input ed output di un programma vengono gestiteda due flussi di dati ( stream): cin per l’input e cout per l’output. Sono definiti inoltre altri due flussi -cerr e clog - il cui scopo e quello di segnalare eventuali messaggi di errore. Tali flussi possono essere mandatianch’essi sul video oppure inviati in un file di log .

Dunque cout (il flusso di output standard) e normalmente diretto al video e cin (il flusso di inputstandard) e normalmente assegnato alla tastiera.

5.1 Ouptut (cout)

Il flusso cout viene usato assieme all’operatore sovraccaricato << (una coppia di segni di "minore" ).

cout << "Frase di output"; // stampa Frase di output sullo schermo

cout << 120; // stampa il numero 120 sullo schermo

cout << x; // stampa il valore della variabile x sullo schermo

Esempio

cout << "Prima frase." << endl;

cout << "Seconda frase." << endl;

produce:

5. Comunicazione da Console 18

Prima frase.

Seconda frase.

5.2 Input (cin)

In C++ l’input standard si effettua applicando l’operatore di estrazione (>>) al flusso cin.

int age;

cin >> age;

dichiara la variabile age di tipo int e quindi aspetta un input da cin (tastiera) per poter memorizzare unvalore intero in tale variabile.

Attenzione! cin elabora l’input ricevuto da tastiera soltanto dopo che e stato premuto il tasto di invioENTER.Quando si usa l’estrattore (>> ) su cin bisogna tener presente il tipo della variabile che si usa permemorizzare il valore letto.

#include <iostream.h>

int main () {

int i;

cout << "Dammi un intero: ";

cin >> i;

cout << "Il valore che mi hai dato e’ " << i;

cout << " e il suo doppio e’ " << i*2 << ".\n";

return 0;

}

e produrra:

Dammi un intero: 702

Il valore che mi hai dato e’ 702 e il suo doppio e’ 1404.

N.B. Si puo anche usare cin per richiedere piu di un dato alla volta:

cin >> a >> b;

e equivalente a:

cin >> a;

cin >> b;

In entrambi i casi l’utente deve fornire due valori dei tipi appropriati, uno per la variabile a ed uno per lavariabile b . Tali valori possono essere separati da uno o piu caratteri spazio o tabulazione o nuova-linea.

6. Strutture di controllo e funzioni 19

6 Strutture di controllo e funzioni

6.1 Strutture di controllo

Cio che e definito ‘istruzione‘ puo essere sia una singola istruzione che un blocco di istruzioni. Se mettiamouna singola istruzione non e necessario racchiuderla tra parentesi graffe ({}), ma naturalmente occorremettere il punto e virgola (;) che la termina. Se vogliamo mettere piu di una istruzione allora occorreracchiuderle tra parentesi graffe ({}) per formare un blocco.

6.1.1 Strutture condizionali: if ed else

Viene usata per eseguire una istruzione o un blocco di istruzioni soltanto se si verifica una determinatacondizione. La sua forma e:

if (Condizione) Istruzione

dove Condizione e una espressione di tipo bool (ossia una espressione il cui risultato e uno dei due valori diverita true o false ). Ad esempio:

if (x == 100) {

cout << "x e’ 100";

} else {

cout << "x non e’ 100";

}

6.1.2 Istruzioni iterative o cicli

I cicli hanno lo scopo di ripetere una istruzione o gruppo di istruzioni un certo numero di volte oppure finoa che rimane vera una certa condizione.

Il ciclo while.

Il suo formato e:

while (Espressione ) Istruzione

ed il suo effetto e semplicemente ripetere Istruzione fintanto che Espressione ha il valore true. Vediamo unesempio:

// conto alla rovescia usando while


int main () {

int n;

cout << "Dammi il valore da cui partire > ";

cin >> n;

while (n>0) {

cout << n << ", ";


--n;

}

cout << "FUOCO!";

return 0;

}

e produrra:

Dammi il valore da cui partire > 8

8, 7, 6, 5, 4, 3, 2, 1, FUOCO!

N.B. Occorre assicurarsi che il ciclo ad un certo punto termini!

Il ciclo do-while.

Il suo formato e:

do Istruzione while (Condizione );

Esso funziona esattamente come il ciclo while tranne il fatto che Condizione viene controllata dopol’esecuzione di Istruzione invece che prima di eseguirla. Vediamo un esempio:

// ripetitore di numeri


int main () {

unsigned long n;

do {

cout << "Dammi un numero (0 per finire): ";

cin >> n;

cout << "Mi hai dato: " << n << "\n";

} while (n != 0);

return 0;

}

e produrra:

Dammi un numero (0 per finire): 12345

Mi hai dato: 12345


Mi hai dato: 160277


Mi hai dato: 0

Il ciclo for.

Il suo formato e:

for ( Inizializzazione; Condizione ; Incremento) Istruzione


ed il suo scopo e quello di ripetere Istruzione finche la condizione Condizione rimane vera, esattamente comeil ciclo while. A differenza di while il ciclo for permette di indicare anche una istruzione di inizializzazioneInizializzazione ed una istruzione di incremento Incremento. Il ciclo for e quindi particolarmente adatto adeseguire delle ripetizioni usando un contatore. Ecco un esempio:

// conto alla rovescia usando un ciclo for


int main () {

for (int n=10; n>0; n--) {

cout << n << ", ";

}

cout << "FUOCO!";

return 0;

}

e produrra:

10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FUOCO!

N.B. I campi Inizializzazione e Incremento sono opzionali. Essi si possono quindi omettere ma non si puoomettere il punto e virgola che li separa da Condizione . Possiamo quindi scrivere for (;n<10;) se nonvogliamo indicare ne Inizializzazione ne Incremento oppure for (;n<10;n++) se vogliamo includere il campoIncremento ma non Inizializzazione.

6.1.3 Biforcazioni di controllo e salti.

L’istruzione break.

Possiamo uscire da un ciclo anche senza che la condizione sia soddisfatta usando una istruzione break. Essasi puo usare per uscire da un ciclo infinito oppure per forzare la terminazione di un ciclo in presenza diqualche anomalia.

L’istruzione continue.

L’istruzione continue termina immediatamente l’iterazione che si sta eseguendo ma non fa uscire dal ciclo.Essa salta tutto il resto del blocco di istruzioni che si sta eseguendo andando direttamente alla fine del bloccoe passando quindi all’iterazione successiva

L’istruzione goto.

L’istruzione goto permette di saltare direttamente ad un altro punto del programma. Deve essere usatasoltanto nei casi di effettiva necessita (che sono estremamente rari) perche essa sovverte la struttura delprogramma.

Il punto di arrivo del salto e indicato dall’etichetta che compare come argomento dell’istruzione goto .L’etichetta deve essere premessa all’istruzione a cui saltare e separata da essa dal carattere due punti (:).

// esempio di ciclo con goto


int main () {


int n=10;

loop:

cout << n << ", "; n--;

if (n>0) {

goto loop;

}

cout << "FUOCO!";

return 0;

}

che produrra anch’esso il risultato dell’esempio del ciclo for :

10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FUOCO!

La funzione exit .

La funzione exit e definita nella libreria standard (stdlib.h).

Essa termina l’esecuzione del programma ritornando un codice di terminazione intero. La sua forma e:

exit(cod) ;

dove cod e un valore intero che viene ritornato al sistema operativo.

6.1.4 L’istruzione di scelta: switch.

L’istruzione switch ha lo scopo di confrontare il valore di una espressione con un certo numero di valoricostanti ed eseguire il blocco di istruzioni associato al valore dell’espressione.

switch (Espressione) {

case Costante1: blocco di istruzioni 1 break;

case Costante2: blocco di istruzioni 2 break;

. . .

default: blocco di istruzioni di default

}

N.B. switch si puo usare soltanto per confrontare una espressione con delle costanti. Non si possono usarevariabili o espressioni o intervalli di valori (case (n*2): e case (1..3): non vanno bene).

6.2 Funzioni

Una funzione e un blocco di istruzioni con un nome che viene eseguito in ogni punto del programma in cuiviene richiamata la funzione usando il nome. Essa si dichiara nel modo seguente:

Tipo Nome ( Argomento1, Argomento2 , ...) Istruzione

dove:


• Tipo e il tipo del valore ritornato dalla funzione;

• Nome e il nome con cui possiamo richiamare la funzione;

• Argomento (possiamo indicarne quanti ne vogliamo, anche nessuno). Un argomento e costituito da unnome di tipo seguito da un identificatore (ad esempio int x ), esattamente come in una dichiarazione divariabile; ed infatti, all’interno della funzione, un argomento si comporta come una variabile (locale).Gli argomenti permettono di passare dei parametri quando la funzione viene richiamata. I parametrisono separati da virgole;

• Istruzione e il corpo della funzione: un blocco di istruzioni racchiuse tra parentesi graffe {}

// esempio di funzione


int somma (int a, int b) {

int r;

r=a+b;

return r;

}

int main () {

int z;

z = somma (5,3);

cout << "Il risultato e’ " << z;

return 0;

}

Il risultato prodotto e:

Il risultato e’ 8

N.B.Il campo di validita (scopo) delle variabili dichiarate in una funzione o in un blocco di istruzioni elimitato alla funzione stessa e al blocco di istruzioni e quindi tale variabile non puo essere usata al di fuoridi tale ambito.

6.2.1 Funzioni senza risultato. L’uso di void.

Supponiamo di voler scrivere una funzione che deve soltanto scrivere qualcosa sullo schermo. Non ci serveche essa ritorni un valore e neppure abbiamo bisogno di passargli dei parametri. Allo scopo il C fornisce unparticolare tipo void. Osserviamo il seguente esempio:

// esempio di funzione void


void stampa (void) {

cout << "Sono una funzione!";

}

int main () {

stampa ();

return 0;

}


che produrra:

Sono una funzione!

6.2.2 Parametri passati per valore e per riferimento.

Negli esempi di funzioni visti finora i parametri venivano passati per valore. In particolare, se il parametroe una variabile viene passato alla funzione il valore della variabile ma non la variabile stessa. Supponiamo,ad esempio, di richiamare la funzione somma nel modo seguente:

int x=5, y=3, z;

z = somma ( x , y );

In questo caso viene richiamata la funzione somma passandogli i valori di x ed y , ossia 5 e 3 , ma non levariabili stesse:

In questo modo, quando la funzione somma e chiamata, i valori delle sue variabili a e b sono 5 e 3 rispetti-vamente. Una modifica di a o b all’interno della funzione somma non cambia i valori delle variabili x ed yesterne ad essa. Questo perche non sono state passate le variabili x ed y alla funzione somma ma soltantoil loro valore.

Ci sono pero casi in cui vogliamo modificare dall’interno di una funzione il valore di variabili definite ester-namente alla funzione stessa. A questo scopo possiamo usare dei parametri passati per riferimento, comenell’esempio:

// passaggio di parametri per riferimento


void raddoppia (int &a, int &b, int &c) {

a*=2;

b*=2;

c*=2;

}

int main () {

int x=1, y=3, z=7;

raddoppia (x, y, z);

cout << "x=" << x << ", y=" << y << ", z=" << z;

return 0;

}

che produrra:

x=2, y=6, z=14

La cosa da notare e che nella dichiarazione di raddoppia il tipo di ciascun parametro e seguito dal carattere ecommerciale (&); esso sta ad indicare appunto un passaggio di parametro per riferimento invece dell’usualepassaggio per valore.


In altre parole noi abbiamo associato le variabili locali a , b e c (i parametri formali della funzione) allevariabili x , y e z (i parametri attuali passati nella chiamata alla funzione) in modo tale chea diventa sinonimodi x ,b sinonimo di y e c sinonimo di z .

Il passaggio di parametri per riferimento permette di scrivere funzioni che calcolano piu di un valore. Adesempio, ecco una funzione che calcola il numero precedente ed il numero successivo del primo parametroche gli viene passato:

// calcolo di piu’ di un valore


void precsucc (int x, int& prec, int& succ) {

prec = x-1;

succ = x+1;

}

int main () {

int x=100, y, z;

precsucc (x, y, z);

cout << "Precedente=" << y << ", Successivo=" << z;

return 0;

}

che produrra:

Precedente=99, Successivo=101

6.2.3 Valori di default per i parametri.

Nella dichiarazione di una funzione si possono specificare dei valori didefault per i parametri. I valori didefault vengono usati nel caso in cui tali parametri vengano omessi nella chiamata di funzione. Ad esempio:

// valori di default per i parametri


int dividi (int a, int b=2) {

int r;

r=a/b;

return r;

}

int main () {

cout << dividi (12);

cout << endl;

cout << dividi (20,4);

return 0;

}

che produrra:

6

5


N.B. la corrispondenza tra parametri attuali e parametri formali e posizionale e quindi in una chiamatasi possono omettere soltanto gli ultimi parametri.

6.2.4 Funzioni sovraccaricate.

Due funzioni distinte possono avere lo stesso nome purche la lista degli argomenti sia diversa. Questo significache possiamo dare lo stesso nome a piu di una funzione purche esse abbiano un diverso numero di parametrio almeno un parametro di dipo diverso.

6.2.5 Ricorrenza.

La ricorrenza (o ricorsivita) e la proprieta di una funzione di poter essere richiamata da se’ stessa, ossiaall’interno del corpo della funzione possono comparire chiamate alla funzione stessa. Questa possibilitarisulta particolarmente utile in certe situazioni in cui il valore da calcolare puo essere definito per induzione. Ad esempio, il fattoriale di un numero intero n:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

si puo definire induttivamente nel seguente modo:

• se n=1 allora n! = 1

• se n>1 allora n!= n * (n-1)!

il che suggerisce la seguente funzione ricorsiva:

// calcolo del fattoriale


long fattoriale (long a) {

if (a > 1) {

return a * fattoriale (a-1);

} else {

return 1;

}

}

int main () {

long n;

cout << "Dammi un numero: ";

cin >> n;

cout << n << "!"<< " = " << fattoriale (n);

return 0;

}

che produrra:

Dammi un numero:9

9! = 362880

N.B.Il tipo del risultato (long) non permette di memorizzare fattoriali maggiori di 12!.

7. Strutture dati 27

6.2.6 Prototipi di funzioni.

Il compilatore per poter effettuare una chiamata di funzione ha bisogno di conoscere soltanto il nome dellafunzione ed il numero e tipo dei suoi parametri (il prototipo della funzione ) mentre non ha alcun bisognodi conoscerne il corpo. Il C++ permette di dichiarare il prototipo di una funzione in modo tale da renderlanota al compilatore e rimandare in seguito la definizione vera e propria della funzione (comprendente ancheil corpo).

La forma di una dichiarazione di prototipo e la seguente:

tipo nome ( tipo_parametro1, tipo_parametro2, ...);

ed e simile alla intestazione di una dichiarazione di funzione eccetto:

• manca la parte Istruzione, ossia il blocco di istruzioni racchiuso tra parentesi graffe {} che costituisceil corpo della funzione.

• termina con il carattere punto e virgola (;)

• nell’elenco dei parametri basta indicare i tipi degli argomenti anche se e consigliabile mettere anche ilnome del parametro benche esso sia opzionale.

N.B. Molti programmatori esperti consigliano di prototipare tutte le funzioni. Questo e particolarmente utilequando un programma contiene molte funzioni o le definizioni delle funzioni sono molto lunghe. In tal casoraccogliere tutti i prototipi nello stesso posto all’inizio facilita la ricerca se non si ricorda come devono essererichiamate (numero e tipo dei parametri).

7 Strutture dati

7.1 Array

Gli array sono sequenze di variabili dello stesso tipo che vengono situate consecutivamente nella memoriaed alle quali e possibile accedere usando uno stesso nome (identificatore) a cui viene aggiunto un indice.

Come tutte le variabili anche gli array devono essere dichiarati prima di poterli usare. Un esempio didichiarazione di un array in C++ e:

tipo nome [dimensione];

dove tipo e il tipo degli elementi ( int, float ...) detto anche tipo base dell’array , nome e un identificatore edimensione, che deve essere racchiuso tra parentesi quadre [], e la dimensione, ossia il numero di elementi,dell’array.

ATTENZIONE! Il campo dimensione deve essere un valore costante in quanto gli array sonoblocchi di memoria di dimensione prefissata ed il compilatore deve conoscere esattamentequanta memoria serve per l’array prima che il programma venga eseguito.


7.1.1 Inizializzazione degli Array.

Come per le variabili semplici, anche per gli array e possibile specificare un valore iniziale. Ad esempio, conla dichiarazione:

int myArray [5] = { 16, 2, 77, 40, 12071 };

si crea un array di 5 numeri, come specificato tra le graffe.

Naturalmente, qualora venga dichiarato un array senza inizializzazione il valore iniziale dei suoi elementirisulta indeterminato (i bit della memoria riservata per l’array conservano i valori lasciati dai programmiprecedenti che la hanno usata).

7.1.2 Accesso ai valori di un Array.

In ogni punto del programma in cui un array risulta visibile possiamo accedere individualmente ad uno deglielementi dell’array per leggerlo o modificarlo esattamente come esso fosse una normale variabile. Il formatoe il seguente:

name[index]

7.1.3 Array multidimensionali.

Un array multidimensionale si puo pensare come un array di array di array di .... Ad esempio, un arraybidimensionale si puo pensare come una tabella bidimensionale i cui elementi appartengono tutti allo stessotipo.

name[index_row][index_col]

7.1.4 Array come parametri.

Potremmo voler passare un array come parametro ad una funzione. In C++ non e possibile passare comeparametro ad una funzione il valore di un array (ossia l’insieme dei valori di tutti i suoi elementi). Possiamopero passare come parametro ad una funzione l’indirizzo dell’array, il che ai fini pratici funziona altrettantobene ed e una operazione molto piu veloce.

Per indicare che un argomento di una funzione rappresenta un parametro di tipo array basta scrivere il tipodegli elementi dell’array (il tipo base dell’array) seguito da una coppia di parentesi quadre []. Ad esempio lafunzione::

void procedura (int arg[])

aspetta un argomento arg di tipo "Array di int ". Per passare alla funzione l’array:

int myArray [40];

e sufficiente scrivere una chiamata della funzione del tipo:


procedura (myArray);

Il passaggio di array (semplici o multidimensionali) come parametri di funzioni e spesso sorgente di errori peri programmatori inesperti. Per una comprensione piu precisa di come funzionano gli array occorre conoscerei puntatori.

7.2 Vector

Area in preparazione.

7.3 Stringhe di caratteri

In C++ non vi e un tipo di variabile predefinito in grado di memorizzare delle stringhe di caratteri: dobbiamousare degli array di caratteri.

Comunque, la libreria standard del C++ contiene un file (che si puo includere con il comando#include<string> ) in cui e definito un tipo string con il quale l’elaborazione di stringhe risulta molto agevolata.

N.B Dopo il contenuto effettivo della stringa viene aggiunto un carattere nullo (’\0’) perindicare la fine della stringa. Pertanto un’array di 20 char potra contenere 19 caratteri effettivi.

7.3.1 Inizializzazione delle stringhe

Per inizializzare una stringa di caratteri si puo usare la stessa notazione usata per gli array:

char mystring[] = { ’H’, ’e’, ’l’, ’l’, ’o’, ’\0’ };

char mystring [] = "Hello";

ATTENZIONE! Assegnazione quali: mystring = "Hello"; mystring[] = "Hello";non sono permesse,come non e permesso: mystring = { ’H’, ’e’, ’l’, ’l’, ’o’, ’\0’ };

7.3.2 Assegnazione di valori alle stringhe

Siccome in una assegnazione il lvalue puo essere soltanto un elemento di un array e non l’intero array, perassegnare una stringa di caratteri ad un array di char dobbiamo scrivere:

mystring[0] = ’H’;

mystring[1] = ’e’;

mystring[2] = ’l’;

mystring[3] = ’l’;

mystring[4] = ’o’;

mystring[5] = ’\0’;

Siccome questo non e molto pratico la libreria standard cstring (che si puo includere con #include<string.h>) contiene la definizione di un certo numero di funzioni quali strcpy (stringcopy) che si puorichiamare nel seguente modo:


strcpy (string1, string2);

L’effetto e copiare il contenuto di string2 in string1. string2 puo essere sia un array sia una stringa costante,il che ci permette di assegnare la stringa costante "Hello" al’array di caratteri mystring usando la seguentenotazione:

strcpy (mystring, "Hello");

Vediamo un esempio:

// assegnazione a stringhe


#include <string.h>

int main () {

char stMyName [20];

strcpy (stMyName,"J. Soulie");

cout << stMyName; return 0;

}

che produce:

J. Soulie

Un altro modo per assegnare un valore ad un array di caratteri e quello di usare direttamente il flusso diinput cin. Nella libreria iostream e infatti definita una funzione getline il cui prototipo e:

cin.getline ( char buffer [], int length, char delimiter = ’ \n’);

dove buffer e l’array di caratteri in cui memorizzare l’input, length e la dimensione dell’array stesso e delimitere il carattere usato per indicare la fine dell’input e per il quale e previsto il carattere nuova linea (’\n’ ) comevalore di default.

Ecco un esempio di uso di cin.getline:

// uso di cin.getline


int main () {

char buff [100];

cout << "Come ti chiami? ";

cin.getline (buff,100);

cout << "Salve " << buff << ".\n";

cout << "La tua squadra preferita? ";

cin.getline (buff,100);

cout << "L’" << buff << " piace anche a me.\n";

return 0;

}


che produrra:

Come ti chiami? Juan

Salve Juan.

La tua squadra preferita? Inter

L’Inter piace anche a me

strcat:

char* strcat (char* dest , const char* src );

// Aggiunge (appende) la stringa src alla fine della stringa dest. Ritorna dest.

strcmp:

int strcmp (const char* str1, const char* str2 );

// Confronta le stringhe str1 ed str2 . Ritorna 0 se sono uguali.

strcpy:

char* strcpy (char* dest, const char* src );

// Copia il contenuto di src in dest. Ritorna dest.

strlen:

size_t strlen (const char* str);

// Ritorna la lunghezza di str.

NOTA: char* ha lo stesso significato di char[]

7.4 Strutture

7.4.1 Strutture dati.

Una struttura dati e un insieme di tipi diversi di dati raggruppati in un’unica dichiarazione. La forma delladichiarazione e la seguente:

struct nome_modello {

tipo1 nome_elemento1;



....

} nome_oggetto;

in cui nome modello e un nome per il modello di struttura e nome oggetto (opzionale) e un identificatoreche denota un oggetto avente la struttura nome modello . Tra le parentesi graffe {} sono indicati i tipi e irispettivi sub identificatori degli elementi che compongono la struttura. Ad esempio:


// Definizione struttura

struct prodotti {

char nome [30];

float prezzo;

} ;

// Oggetti tipo ‘prodotti‘

prodotti mele;

prodotti arance, meloni;

Il campo opzionale nome oggetto che compare alla fine della dichiarazione di una struttura serve a dichiararedirettamente oggetti di tale tipo. Ad esempio avremmo potuto scrivere:

struct prodotti {

char nome [30];

float prezzo;

} mele, arance, meloni;

Per ooperare sui campi che costituiscono gli oggetti bisogna usare il punto (.), tra il nome dell’oggetto ed ilnome del campo:

mele.nome

mele.prezzo

arance.nome

arance.prezzo

meloni.nome

meloni.prezzo

ciascuna di esse appartiene al rispettivo tipo: mele.nome , arance.nome e meloni.nome sono di tipo char[30],mentre mele.prezzo , arance.prezzo e meloni.prezzo sono di tipo float.

7.4.2 Strutture annidate.

Le strutture si possono annidare in modo tale che un elemento di una struttura puo essere a sua volta unastruttura.

struct film_t {

char titolo [50];

int anno;

}

struct amici_t {

char nome [50];

char email [50];

film_t film_preferito;

} carlo, maria;

Dopo tale dichiarazione possiamo usare le espressioni:


carlo.nome

maria.film_preferito.titolo

carlo.film_preferito.anno

7.5 Tipi definiti dall’utente

7.5.1 Definizione di propri tipi (typedef).

Il C++ permette di definire nuovi tipi basati su altri tipi di base o precedentemente definiti. Per fare questosi usa la parola chiave typedef, nel seguente modo:

typedef tipo_esistente nome_nuovo_tipo ;

in cui tipo esistente e un tipo fondamentale del C++ o un altro tipo definito precedentemente enome nuovo tipo e il nome assegnato al nuovo tipo che stiamo definendo. Ad esempio:

typedef char C;

typedef unsigned int WORD;

typedef char field [50];

definiscono tre nuovi tipi: C , WORD e field come char, unsigned int e char[50] rispettivamente. I nuovi tipisi possono usare in seguito scrivendo, ad esempio:

C unchar, altrochar;

WORD parola;

field nome;

typedef si usa di solito per definire un tipo che viene usato molte volte nel programma e che e possibile debbaessere cambiato in una nuova versione del programma. Si usa anche per dare un nome sintetico quando iltipo che si intende utilizzare ha un nome molto complesso.

7.5.2 Unioni

Le unioni permettono di utilizzare la stessa zona di memoria per memorizzare oggetti appartenenti a tipidifferenti. La sua dichiarazione e simile a quella delle strutture ma il suo significato e completamente diverso:

union nome_modello {

tipo1 elemento1;

tipo2 elemento2;

tipo3 elemento3;

... } nome_oggetto;

Tutti gli elementi della union occupano lo stesso spazio di memoria. La dimensione di tale spazioe quella dell’elemento che ne richiede di piu. Ad esempio:


union tipi_t {

char c;

int i;

float f;

} x;

definisce tre elementi:

x.c

x.i

x.f

ciascuno di un tipo diverso. Essi non si possono usare contemporaneamente in quanto utilizzano la stessamemoria. In altre parole l’oggetto x puo contenere un valore di tipo char o un valore di tipo int o un valoredi tipo float ma soltanto uno di essi. Questo spiega il nome UNION: l’insieme dei valori memorizzabiliin x e l’unione dei tre insiemi di valori char , int e float .

7.5.3 Unioni anonime

In C++ possiamo avere delle unioni anonime. Se inseriamo una unione in una struttura senza indicare ilnome di un oggetto (il nome che viene di norma posto alla fine, dopo la parentesi graffa }) l’unione si diceanonima e possiamo accedere direttamente agli elementi come fossero campi della struttura. Osserviamo ladifferenza tra le seguenti due dichiarazioni:

// unione

struct {

char titolo[50];

char autore[50];

union {

float euro;

int lire;

} prezzo;

} libro;

// unione anonima

struct {

char titolo[50];

char autore[50];

union {

float euro;

int lire;

};

} libro;

La differenza e che nel primo caso abbiamo dato un nome (prezzo) all’unione mentre nel secondo caso loabbiamo omesso.La differenza sta nel modo di accedere ai valori euro e lire. Nel primo caso si deve usare:

8. Puntatori e reference 35

libro.prezzo.euro

libro.prezzo.lire

mentre nel secondo basta scrivere:

libro.euro

libro.lire

Ricordiamo che siccome si tratta di una unione i campi euro e lire occupano la stessa zona di memoria equindi non si possono usare per memorizzare due valori diversi. In altre parole si puo registrare il prezzo ineuro oppure in lire ma non entrambi.

7.5.4 Enumerazioni (enum)

Le enumerazioni permettono di creare dei nuovi tipi che non sono basati sui tipi definiti precedentemente.La forma della dichiarazione e la seguente:

enum nome_enum {

id_valore1,

id_valore2,

id_valore3, ...

} nome_oggetto;

Possiamo, ad esempio, creare un nuovo tipo color per memorizzare dei colori:

enum colori {nero, blu, verde, viola, rosso, porpora, giallo, bianco};

Abbiamo creato un nuovo tipo di dato non basato su altri esistenti: il tipo colori, i cui possibili valori sonotutti e soli gli identificatori che abbiamo racchiuso tra parentesi graffe {}.

8 Puntatori e reference

Il C++ fa dei puntatori un punto di forza (se non IL punto di forza) e fornisce un supporto ad essi persinosuperiore a quello fornito dal Pascal. E‘ quindi caldamente consigliata una lettura attenta di quanto seguee sarebbe bene fare pratica con i puntatori non appena possibile.

8.1 I Puntatori

I puntatori possono essere pensati come maniglie da applicare alle porte delle celle di memoria per poteraccedere al loro contenuto sia in lettura che in scrittura, nella pratica una variabile di tipo puntatore contienel’indirizzo di una locazione di memoria.

short *Puntatore1;

Persona *Puntatore3;

double **Puntatore2;

int UnIntero = 5;

int *PuntatoreAInt = &UnIntero;


Il carattere * (asterisco) indica un puntatore, per cui le prime tre righe dichiarano rispettivamente unpuntatore a short int , un puntatore a Persona e un puntatore a puntatore a double. La quinta riga dichiaraun puntatore a int e ne esegue l’inizializzazione mediante l’operatore & (indirizzo di) che serve ad otterel’indirizzo della variabile (o di una costante o ancora di una funzione) il cui nome segue l’operatore. Siosservi che un puntatore a un certo tipo puo puntare solo a oggetti di quel tipo, (non e possibile ad esempioassegnare l’indirizzo di una variabile di tipo float a un puntatore a char, come mostra il codice seguente), omeglio in molti casi e‘ possibile farlo, ma viene eseguita una coercizione

Nelle dichiarazioni di puntatori bisogna prestare attenzione a diversi dettagli che possono essere meglioapprezzati tramite esempi:

float *Reale, UnAltroReale;

int Intero = 10;

const int *Puntatore = &Intero;

int *const CostantePuntatore = &Intero;

const int *const CostantePuntatoreACostante = &Intero;

La prima dichiarazione contrariamente a quanto si potrebbe pensare non dichiara due puntatori a float, maun puntatore a float (Reale) e una variabile di tipo float (UnAltroReale): * si applica solo al primo nomeche lo segue e quindi il modo corretto di eseguire quelle dichiarazioni era

float *Reale, *UnAltroReale;

E’ possibile dichiarare puntatori generici:

void *PuntatoreGenerico;

I puntatori void possono essere inizializzati come un qualsiasi altro puntatore tipizzato, e a differenza diquesti ultimi possono puntare a qualsiasi oggetto senza riguardo al tipo o al fatto che siano costanti, variabilio funzioni; tuttavia non e‘ possibile eseguire sui puntatori void alcune operazioni definite sui puntatoritipizzati.

8.2 Operazioni sui puntatori

Dal punto di vista dell’assegnamento, una variabile di tipo puntatore si comporta esattamente come unavariabile di un qualsiasi altro tipo primitivo, basta tener presente che il loro contenuto e‘ un indirizzo dimemoria:

int Pippo = 5, Topolino = 10;

char Pluto = ’P’;

int *Minnie = &Pippo;

int *Basettoni;

void *Manetta;

Esempi di assegnamento a puntatori:


Minnie = &Topolino;

Manetta = &Minnie; // "Manetta" punta a "Minnie"

Basettoni = Minnie;

// "Basettoni" e "Minnie" ora puntano allo stesso oggetto

L’operazione piu‘ importante che viene eseguita sui puntatori e quella di dereferenziazione o indirezioneal fine di ottenere accesso all’oggetto puntato; l’operazione viene eseguita tramite l’operatore di deref-erenzazione * posto prefisso al puntatore, come mostra il seguente esempio:

short *P;

short int Val = 5;

P = &Val; // P punta a Val (cioe‘ Val e *P sono lo stesso oggetto);

cout << "Ora P punta a Val:" << endl;

cout << "*P = " << *P << endl;

cout << "Val = " << Val << endl << endl;

*P = -10; // Modifica l’oggetto puntato da P

cout << "Val e‘ stata modificata tramite P:" << endl;

cout << "*P = " << *P << endl;


Val = 30;

cout << "La modifica su Val si riflette su *P:" << endl;

cout << "*P = " << *P << endl;


Il codice appena mostrato fa si‘ che il puntatore P riferisca alla variabile Val, ed esegue una serie di asseg-namenti sia alla variabile che all’oggetto puntato da P mostrandone gli effetti. L’operatore * prefisso ad unpuntatore seleziona l’oggetto puntato dal puntatore cosi‘ che *P utilizzato come operando in una espressioneproduce l’oggetto puntato da P. Ecco quale sarebbe l’output del precedente frammento di codice se eseguito:

Ora P punta a Val:

*P = 5

Val = 5

Val e‘ stata modificata tramite P:

*P = -10

Val = -10

La modifica su Val si riflette su

*P: *P = 30

Val = 30

Sui puntatori sono anche definiti gli usuali operatori relazionali:

• < minore di

• > maggiore di

• <= minore o uguale

• >= maggiore o uguale


• == uguale a

• != diverso da

8.3 Puntatori vs Array

In C++ le dichiarazioni char Array[] = "Una stringa" e char* Ptr = "Una stringa" hanno lo stesso effetto,entrambe creano una stringa (terminata dal carattere nullo) il cui indirizzo e‘ posto rispettivamente in Arraye in Ptr, e come mostra l’esempio un char* puo‘ essere utilizzato esattamente come un array di caratteri:

char Array[] = "Una stringa";

char* Ptr = "Una stringa";

// la seguente riga stampa tutte e due le stringhe

// si osservi che non e‘ necessario dereferenziare

// un char* (a differenza degli altri tipi di

// puntatori)

cout << Array << " == " << Ptr << endl;

// in questo modo, invece, si stampa solo un carattere:

// la dereferenzazione di un char* o l’indicizzazione

// di un array causano la visualizzazione di un solo

// carattere perche‘ in effetti si passa all’oggetto

// cout non un puntatore a char, ma un oggetto di tipo

// char (che cout tratta giustamente in modi diversi)

cout << Array[5] << " == " << Ptr[5] << endl;

cout << *Ptr << endl;

Un puntatore e‘ piu‘ flessibile di quanto non lo sia un array, anche se a costo di un maggiore overhead.

8.4 Uso dei puntatori

I puntatori sono utilizzati sostanzialmente per quattro scopi:

1. Realizzazione di strutture dati dinamiche (es. liste linkate);

2. Realizzazione di funzioni con effetti laterali sui parametri attuali;

3. Ottimizzare il passaggio di parametri di grosse dimensioni;

4. Rendere possibile il passaggio di parametri di tipo funzione.

Utilizzando i puntatori invece e‘ possibile realizzare ad esempio una lista il cui numero massimo di elementinon e‘ definito a priori:

#include < iostream >

using namespace std;

// Una lista e‘ composta da tante celle linkate

// tra di loro; ogni cella contiene un valore


// e un puntatore alla cella successiva.

struct TCell {

float AFloat; // per memorizzare un valore

TCell *Next; // puntatore alla cella successiva

};

// La lista viene realizzata tramite questa

// struttura contenente il numero corrente di celle

// della lista e il puntatore alla prima cella

struct TList {

unsigned Size; // Dimensione lista

TCell *First; // Puntatore al primo elemento

};

int main(int, char* []) {

TList List; // Dichiara una lista

List.Size = 0; // inizialmente vuota

int FloatToRead;

cout << "Quanti valori vuoi immettere? " ;

cin >> FloatToRead;

cout << endl;

// questo ciclo richiede valori reali

// e li memorizza nella lista

for(int i=0; i < FloatToRead; ++i) {

TCell *Temp = List.First;

cout << "Creazione di una nuova cella..." << endl;

List.First = new TCell;

// new vuole il tipo di

// variabile da creare

cout << "Immettere un valore reale " ;

// cin legge l’input da tastiera e l’operatore di

// estrazione >> lo memorizza nella variabile.

cin >> List.First -> AFloat;

cout << endl;

List.First -> Next = Temp; // aggiunge la cella in testa alla lista

++List.Size; // incrementa la dimensione della lista

}

// il seguente ciclo calcola la somma dei valori contenuti nella lista;

// via via che recupera i valori, distrugge le relative celle

float Total = 0.0;

for(int j=0; j < List.Size; ++j) {

Total += List.First -> AFloat;

// estrae la cella in testa alla lista...

TCell *Temp = List.First;

List.First = List.First -> Next;

// e quindi la distrugge

cout << "Distruzione della cella estratta..." << endl;

delete Temp;

}

9. Programmazione a oggetti 40

cout << "Totale = " << Total << endl;

return 0;

}

Il programma sopra riportato programma memorizza in una lista un certo numero di valori reali, aggiungendoper ogni valore una nuova cella; in seguito li estrae uno ad uno e li somma restituendo il totale; via via cheun valore viene estratto dalla lista, la cella corrispondente viene distrutta.

Nel caso sia necessario necessario allocare e deallocare interi array, in questi casi si ricorre agli operatorinew[]e delete[]:

// alloca un array di 10 interi

int* ArrayOfInt = new int[10];

// ora eseguiamo la deallocazione

delete[] ArrayOfInt;

8.5 I reference

yyy

8.6 Uso dei reference

yyy

8.7 Puntatori vs Reference

yyy

9 Programmazione a oggetti

xxx

9.1 Strutture e campi funzione

yyy

9.2 Sintassi della classe

yyy

9.3 Definizione delle funzioni membro

yyy

10. File Handling 41

9.4 Costruttori

yyy

9.5 Distruttori

yyy

9.6 Membri static

yyy

9.7 Membri const e mutable

yyy

9.8 Costanti vere dentro le classi

yyy

9.9 Membri volatile

yyy

9.10 Dichiarazioni friend

yyy

10 File Handling

Esaminiamo le funzioni piu utilizzate per la gestione dei file:

• FILE*fopen( const char *fname, const char *mode) : Apre un file in una delle seguenti modalita:

– ”r” : apre un file testo in sola lettura;

– ”w” : crea un file testo in scrittura;

– ”a” : appende in un file testo;

– ”rb”: file binario in sola lettura;

– ”wb” : file binario in scrittura;

– ”ab” : appende in file binario;

– ”r+” : apre un file di testo in lettura/scrittura;

– ”w+” : crea un file di testo in lettura/scrittura;

10. File Handling 42

– ”a+” : apre un file testo in lettura/scrittura;

– ”rb+” : apre un file binario in lettura/scrittura;

– ”wb+” : crea un file binario in lettura/scrittura;

– ”ab+” : apre un file binario in lettura/scrittura;

• intfwrite(const void *buffer, size t size, size t count, FILE *stream) Scrive ’buffer’ in un file, prendendocount volte pacchetti grandi size bytes;

• intfread( void *buffer, size t size, size t num, FILE *stream) : legge ’buffer’ da un file, prendendocount volte pacchetti grandi size bytes;

• int fclose(FILE *stream) : Chiude un file precedentemente aperto (ritorna 0 in caso di successo,altrimenti EOF );

Riportiamo qualche esempio per ricordarci meglio il funzionamento:

10.1 Esempio: Salvare una stringa in un file

Dando per scontato che textEdit sia un’istanza della classe QTextEdit (QT):

...

FILE *myFile = fopen("textfile.txt","w") ;

fwrite(textEdit1->text(),strlen(textEdit1->text()), 1, myFile);

fclose(myFile);

...

10.2 Esempio: Leggere una stringa da un file

Dando per scontato che textEdit sia un’istanza della classe QTextEdit (QT):

...

FILE *myFile = fopen("config.txt","r") ;

void *buffer;

char myString[64]="";

fread(buffer,1024, 10, myFile);

sprintf(myString,"%s",buffer);

textEdit1->setText(myString);

fclose(myFile);

...

11. Database handling 43

11 Database handling

Ecco un esempio per connettersi ad un database mySql:

// Impostazioni per la connessione

QSqlDatabase*defaultDB =QSqlDatabase::addDatabase("QMYSQL3");

defaultDB->setDatabaseName("test");

defaultDB->setUserName("root");

defaultDB->setPassword("root");

defaultDB->setHostName("localhost");

if ( defaultDB->open() ) {

// Database successfully opened; we can now issue SQL commands.

cout << "DATABASE CONNECT!!!" << endl;

QSqlQuery query( "SELECT ID, DESCRIZIONE FROM tablename" );

if ( query.isActive() ) {

while ( query.next() ) {

cout<< query.value(0).toString() + ": " +query.value(1).toString() << endl;

}

}

}

12 Esercizi di base

12.1 Scrive un testo sul monitor


int main () {

cout << "Ciao! \n" << endl;

return 0 ;

}

12.2 Contatore con ciclo for


int main () {

int n ;

for (n=1 ; n <= 10 ; n++) {

cout << n << endl;

}

return 0 ;

}

12.3 Contatore con ciclo While


12. Esercizi di base 44

int main () {

int n=1;

do {

cout << n << endl;

n++;

}

while (n!=10);

return 0;

}

12.4 Contatore che indica da quanti caratteri e composta una stringa


int contastring (const char *);

int main () {

char stringa [80];

cout << "inserisci 1 stringa di non piu di 80 caratteri:" ;

cin >> stringa;

cout << contastring (stringa) << endl;

return 0;

}

int contastring (const char *s) {

int x;

for (x=0 ; *s!=’\0’ ; s++) {

++x;

}

return x;

}

12.5 Programma che calcola il massimo e il minimo in una successione di interi

# include <iostream.h>

# include <stdlib.h>

int main () {

const int MAX_DIM = 100;

const int MAXINT = 32767;

int n;

int vett [MAX_DIM];

cout << "Indica il numero d elementi da inserire: ";

cin >> n;

if (n >= MAX_DIM || n < 0) {

cout << " \n Numero di elementi errato\n";

exit (1);

}

cout << endl << "Inserisci i dati" << endl;

for (int i=0; i<n; i++) {


cin >> vett[i];

int max = -MAXINT;

int min = MAXINT;

for (i=0; i<n; i=i+1) {

if (vett[i] > max)

max= vett[i];

if (vett[i] < min) min = vett[i];

}

cout << "Il massimo e " << max << " mentre il minimo e " << min << endl; return 0;

}

12.6 Programma che calcola perimetro e area di un triangolo di cui si conoscono

le misure dei lati


# include <math.h>

# include <stdlib.h>

int main () {

double a, b, c, perimetro, sp, area;

cout << "Inserisci la lunghezza dei 3 lati del triangolo: " <<endl;

cin >> a >> b >> c;

if (a > (c+b) || b > (a+c) || c > (a+b)) {

cout << "1 lato nn puo’ essere maggiore "<<endl;

cout << "della somma degli altri 2!" <<endl;

exit (1);

}

perimetro = a+b+c;

sp = perimetro/2;

area = sqrt(sp * (sp-a)*(sp-b)*(sp-c));

cout << "Il perimetro del triangolo e’: " << perimetro << " e l’area e’: " << area <<endl;

return 0;

}

12.7 Calcolo di decine, centinaia, migliaia di un numero fornito in input


// calcola migliaia,centinaia,decine,unita di 1 numero;

int main () {

int numero;

cout << "Scrivi un numero intero non negativo " <<endl;

cout << "(e che sia piu piccolo di 10.000)"<<endl;

cin >> numero;

int migliaia, centinaia, decine, unita;

migliaia = numero/1000;

centinaia = (numero/100)-(migliaia*10);

decine = (numero/10)-(migliaia*100+centinaia*10);


unita = numero-(migliaia*1000+centinaia*100+decine*10);

cout << "Il numero e composto da: "<< endl; cout << migliaia << " migliaia, " << centinaia;

cout << " centinaia, " << decine << " decine, " << unita << " unita."<< endl;

return 0;

}

12.8 Lettura di un file di testo presente su disco fisso


#include <fstream.h>

int main () {

int a , b;

fstream dati ("c:\\dati.txt" ,ios::in);

//lettura di un file di nome "dati.txt" presente in c:

dati >> a;

dati >> b;

cout << a << "e" << b;

return 0;

}

12.9 Scrittura su file di una stringa di caratteri

#include <fstream.h>


int main () {

fstream f;

char testo []={’c’,’i’,’a’,’o’};

f.open ("prova.txt", ios::out);

f.write((char*)(&testo), sizeof(char[4]));

return 0;

}

12.10 Semplice programma sull’utilizzo del tipo enum


void main () {

enum elemento {a, b, c, d} ;

int elem ;

cout << "Inserisci nome elemento"<<endl ;

cin >> elem ;

if (elemento (elem) == a) {

cout << "ok!" ;

} else {

cout << "no!";

}

}


12.11 Programma che permette di calcolare il numero di righe e caratteri di

un testo fornito in input


int main () {

char ch ;

int nc=0 , nl=0; //numero caratteri e righe del testo

cout << "Introduci un testo che termini con il carattere punto ’.’: " << endl;

while (cin.get(ch) && (ch != ’.’)) {

switch (ch) {

case ’\t’: case ’ ’: break;

case ’\n’: nl++; break;

default: nc++; break;

}

}

cout << "numero linee: " << (nl+1) << endl << "numero caratteri: " << nc << endl;

return (0);

}

12.12 Elevamento a potenza


/** ** 2 raised to the power of 10: 1024 **/

int main() {

int value = 2;

int pow = 10;

cout << value << " raised to the power of " << pow << ": \t";

int res = 1;

// loop control statement:

// repeat calculation of res

// until cnt is greater than pow

for ( int cnt=1; cnt <= pow; ++cnt ) {

res = res * value;

}

cout << res << endl;

}

12.13 Programma per la verifica dei numeri primi


void main() {

int a,i;

cout << "Digita un numero (maggiore di 1):\n";

cin >> a;

for(i=2; i<=a; i++) {

if (i==a) {


cout << "e un numero primo."; break;

}

if (a%i==0) {

cout << "non e un numero primo.";

break;

}

}

}

12.14 Conversione da numero decimale a frazione corrispondente


void main() {

int a,b;

double n;

cout << "Inserisci un numero decimale (usa il punto): ";

cin >> n; n*=10; //supponendo che i decimali abbiano una sola cifra dopo lo zero

a=(int)n; //conversione double->int necessaria per i calcoli successivi

cout << "La frazione e’ " << a <<"/10"<< "\n";

b=10; // inizializzo il denominatore

// il denominatore e sempre 10 quindi mi interessa che il num sia divisibile solo per 2 e 5

// di seguito sarebbe da usare while invece di if ma intanto 10 si puo dividere 1 sola volta per 2 o 5

if (a%2==0) {

a/=2; b/=2;

}

if (a%5==0) {

a/=5; b/=5;

}

cout << "Equivalente a " << a << "/" << b;

}

12.15 Semplice calcolatrice con possibilita di eseguire calcoli consecutivi


void main () {

int n1,n2; //per semplicita suppongo che i 2 numeri siano interi char op;

cout<<"Inserisci il primo numero:"<<endl;

cin>>n1;

for (;;) {

//ciclo for infinito (non molto "elegante" da usare ma utile e semplice)

cout<<"Inserisci l’operatore (+ , - , * , /) o ’q’ per interromepere:"<<endl;

cin>>op;

if (op==’q’) break;

cout<<"Inserisci l’altro numero:"<<endl;

cin>>n2;

switch (op) {

13. QT [ Trolltech ] 49

//uso lo statement switch-case che e l’ideale in questa situazione

case ’+’: n1+=n2; break;

case ’-’: n1-=n2; break;

case ’*’: n1*=n2; break;

case ’/’: n1/=n2; break;

}

cout<<"Il risultato e: "<<n1<<endl;

}

}

13 QT [ Trolltech ]

Qt e una libreria di classi della ditta norvegese Trolltech per una programmazione indipendente dalla pi-attaforma in C++. Il gestore di finestre di Linux KDE si basa sul pacchetto Qt . In origine Qt era sotto untipo di licenza inaccettabile da molti utenti Linux. Per questa ragione fu sviluppata la libreria GTK+, laquale costituisce la base per il gestore di finestre Gnome. Nel frattempo, la versione Qt Linux , cosi’ comequella MacOS e’ stata resa disponibile sotto la licenza GPL, incluso tutto il codice sorgente.

Qt per Windows, invece, e’ ancora sotto licenza ad uso commerciale. Una versione di prova limitata nel tempopuo’ essere scaricata dal loro sito - sara’ differenziata dall’uso, che potra’ essere commerciale o didattico.

Oltre alla versione per Windows, Linux(Unix) e Mac e’ disponibile una versione "embedded", che gira suvarianti di sistemi "embedded" Linux ed fornisce un’amministrazione piu’ leggera delle finestre.

Incluso vi e’ il generatore di interfaccia grafica utente (GUI) Qt Designer. C’e’ una dettagliata documen-tazione sui progetti di esempio, una guida di inizio rapido ed una visione d’insieme delle classi.

Qt Designer genera come output una descrizione in formato XML della GUI. Usando lo strumento Qt qmakesi puo’ generare un Makefile funzionante ricavato dalla descrizione in XML. Questo Makefile poi generadel codice sorgente C++ dalla descrizione della GUI (Qt-Tool: uic) e chiama il compilatore Meta ObjectCompiler (Qt-Tool: moc). Quest’ultimo traduce le estensioni specifiche del linguaggio Qt in codice sorgenteC++. Dopodiche’ puo’ essere usata una procedura standard di make per compilare l’eseguibile.

La seguente sequenza e’ necessaria per generare i file sorgente manualmente (Il file di input e’ MyDialog.ui):

* uic MyDialog.ui > MyDialog.h

* uic -impl MyDialog.h MyDialog.ui > MyDialog.cpp

* moc -o moc_MyDialog.cpp MyDialog.h

Qt gira su diversi sistemi operativi quali Linux, Win32, MacOS, Solaris, IRIX, AIX, HP-UX.

Risorse:

Sito principale: http://www.trolltech.com

Sito sviluppatori: http://www.qtcentre.org/

13.1 Tutorial

xxx

http://www.trolltech.com

http://www.qtcentre.org/

C / C++ - SourceForgegnurantudoc.sourceforge.net/linux/myCpp/myCpp.pdfC / C++ myCpp [ Stefano...

Documents

Transcript of C / C++ - SourceForgegnurantudoc.sourceforge.net/linux/myCpp/myCpp.pdfC / C++ myCpp [ Stefano...