La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

C. Rocchini - C++1 C/C++ Claudio Rocchini IGM. C. Rocchini - C++2 -1 Pre Introduzione.

Presentazioni simili


Presentazione sul tema: "C. Rocchini - C++1 C/C++ Claudio Rocchini IGM. C. Rocchini - C++2 -1 Pre Introduzione."— Transcript della presentazione:

1 C. Rocchini - C++1 C/C++ Claudio Rocchini IGM

2 C. Rocchini - C Pre Introduzione

3 C. Rocchini - C++3 Il C/C++ Il C++ e un linguaggio di programmazione. E il lunguaggio utilizzato per creare i programmi (insieme allAssembler), (es. Windows, Linux, Office, OpenOffice, Apache, Perl, PHP, Oracle, PostgreSql, AdobePhotoshop, etc. sono scritti un C/C++) Lefficienza e uno degli obiettivi principali (supporto run-time minimo, contrapposto a Java, Basic, PHP, Perl : support RE massimo + garbage-collector). Ma e anche un linguaggio molto espressivo. Nasce in ambiente industriale (non accademico o umanistico).

4 C. Rocchini - C Introduzione

5 C. Rocchini - C++5 Il Mio primo programma #include //libreria stdio int main()//funzione principale {//Inizio blocco printf(Buongiorno);//Stampa buongiorno return 0;//Riturna il valore 0 }//Fine blocco // La spaziatura non conta // Tutto i comandi finiscono con ; // I bocchi sono delimitati da {}

6 C. Rocchini - C++6 Struttura TipoRisultato NomeFunzione( Parametri) { istruzione; … return valore_ritorno; } Altra_Funzione … // Commento di una linea /* Commento di piu linee */

7 C. Rocchini - C++7 Nota sullo stile La spaziatura, la tabulazione e i ritorni a capo non hanno alcun significato (al contrario del Basic o del Fortran). Questo non vuol dire che bisogna scrivere disordinatamente. Di solito si indenta (tabularizza) i blocchi fra parentesi per facilitare la lettura. I nomi devono essere significativi.

8 C. Rocchini - C++8 Nota sullo stile 2 Esiste un campionato mondiale di C scritto disordinato: The International Obfuscated C Code Contest, Uno dei vincitori: main() { printf(&WIN32["\021%six\012\0"],(WIN32)["have"]+"fun"-0x60);}

9 C. Rocchini - C++9 Nota sullo stile 3 #define _ F-->00||F-OO--; int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO() { _-_-_-_ _-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_ _-_-_-_ }

10 C. Rocchini - C++10 Esercitazione Es0: applicazione console Consultate i lucidi relativi alla esercitazione 0: applicazione console

11 C. Rocchini - C – Tipi Fondamentali

12 C. Rocchini - C++12 Tipi fondamentali float x;// x e una variabile in virgola mobile // in Basic: dim x as single int y = 7;// y e una var. intera con valore iniz. 7 float fun(int x); // fun e una funzione da float a int // in Basic: function fun( x as integer ) as single char c;// c e un carattere double z;// z e una variabile in doppia precisione // void = tipo nullo esempio: void sub();// sub e una procedura (subroutine)

13 C. Rocchini - C++13 Costruire Altri Tipi int * punt;// Puntatore ad intero char vet[7];// Vettore di caratteri double & d;// Riferimento ad un double // Enumerazioni enum giorni { lunedi, martedi, mercoledi, … }; // Strutture: struct Coordinata { double latitudine; double longitudine; };// In basic: structure // Classi… (come vedremo piu avanti)

14 C. Rocchini - C++14 Bool (Valore di verità) bool x = true;// Variabile inizializzata bool y = false; int a = 1; int b = 1; bool k = a==b;// a e uguale a b? bool q = (a!=0) && (b>7);// Diverso, maggiore

15 C. Rocchini - C++15 Char (carattere) char c = a;// Carattere letterale char k = 32;// Conversione da codice ascii int c = int($);// Conversione in codice ascii if( isupper(c) )..// Esempio di funzioni bool k = isdigit(k);// k e una cifra (0-9) // Nota: da non confondersi con string!

16 C. Rocchini - C++16 Tipi interi int a = 3;// Intero standard(4-8 byte) short int s;// Intero a 2-4 byte short s;// Scrittura abbreviata long int l;// Intero 4-8 byte long l;// Scrittura abbreviata unsigned int u;// Intero senza segno unsigned u;// Scrittura abbreviata unsigned long lu;// Intero lungo positivo int x = 3*5+7-4/2;// Espressioni int k = 15%7;// =1, operatore modulo = resto divisione int k = 0xFE;// Costanti esadecimali

17 C. Rocchini - C++17 Virgola mobile float x = 1;// Singola precisione double y = 3.14;// Doppia precisione double z = 1.2e10;// Notazione esponensiale // Espressioni e funzioni double t = 3*7-sqrt(k)+sin(9); double z = 3^y;// Esponenziale int round = int(z+0.5);// Arrotondamento ad intero int trunc = int(z);// Troncamento ad intero

18 C. Rocchini - C++18 void void x;// Variabile nulla: VIETATO void sub();// Procedura (non ritorna niente) void * p;// Puntatore a qualcosa: utile per // dichierare puntatori generici di // tipo sconosciuto.

19 C. Rocchini - C++19 Tipi Enumerati enum e1 { LUN, MAR, MER, GI };// Non specificata enum e2 { A=2, B, C, D };// Inizio specificato enum e3 { K=1, H=99 };// Tutti specificati enum e1 pippo;// Variabile di tipo enum int x = MAR;// Utilizzo del valore cost. switch(pippo)// Utilizzo tipico: case { case LUN: … LUN = 99;// Errore!

20 C. Rocchini - C++20 Introduzione ai puntatori int a = 5;// Una variabile intera int *p = &a; // p è un puntatore a intero, // viene assegnato allindirizzo // di a. a = 6; *p = 7;// a ora vale 7 int * q = 0;// 0, valore speciale // Puntatore nullo Valore = 5 Cella di Memoria di a Indirizzo in memoria della cella: Il puntatore alla cella. … Valore = 5 …

21 C. Rocchini - C++21 Costanti const double PI = ;// Valore costante PI = 4;// Errore! const char * p;// Il contenuto e costante *p = w;// Errore p = 0;// OK char * const p;// Il puntatore e costante *p = w;// OK p = 0;// Errore

22 C. Rocchini - C++22 Vettori Statici char v[10];// Vettore di 10 elemeni (da 0 a 9) int x; v[7] = 11;// Accesso ad un elemento v[999] = 1;// Errore catastrofico! // Forse distruggi x double mat[3][3];// Vettore bidimensionale mat[0][2] = 9;// Accesso ad un elemento char *p = &(v[0]);// Indirizzo del primo elem. char *p = v;// Scrittura abbreviata int a = fun(); char w[a];// Errore, dinamico const int b = 10; char x[b];// Ok, statico

23 C. Rocchini - C++23 Dichiarazioni Multiple int a,b,c;// Tre interi char k, *p;// Un carattere ed un puntatore bool y,v[11];// Un booleano ed un vettore

24 C. Rocchini - C++24 Regole di Visibilità int x = 1;// Globale al modulo void sub() { x = 7;// Modifico la globale int x = 2;// Locale alla procedura … { int x = 3;// Locale al sottoblocco // Qui x vale 3 int y = 99; } // Qui y non e dichiarata! }

25 C. Rocchini - C++25 typedef unsigned long * p;// Puntatore ad intero lungo s.s. typedef unsigned long * Pointer;// Definizione di tipo Pointer p;// Stesso tipo di p typedef double Matrix[9][9];// Tipo matrice 9x9 Matrix m;// Dichiarazione m[2][1] = 3;

26 C. Rocchini - C++26 Strutture struct Registrazione// Dichierazione di tipo { bool ok; int valore; double x; };// Notare il punto e virgola Registrazione r;// Dichiarazione variabile r.valore = 3;// Utilizzo r.x = 4.5;

27 C. Rocchini - C++27 Strutture 2 struct Dipendente { string nome; string cognome; int eta; }; … Dipendete d1,d2; d1.nome = claudio; d1.eta = 37; d2.nome = claudia;

28 C. Rocchini - C++28 Puntatore a Strutture struct Registrazione// Dichierazione di tipo { bool ok; int valore; double x; };// Notare il punto e virgola Registrazione a;// Una struttura Registrazione * p = &a;// Puntatore a struttura a.valore = 5; (*p).valore = 3;// Accesso ai campi p->valore = 7;// Altra scrittura Registrazione k = {false,3,0.9};// Inizializzazione

29 C. Rocchini - C++29 Operatore sizeof // restituisce la dimensione in byte di una variabile sizeof(char)// = 1 sizeof(short)// = 2 sizeof(int)// = 2 o 4 sizeof(long)// = 4 o 8 sizeof(double)// = 8 sizeof(char *)// = 4 (ma 8 proc. 64 bit) sizeof(double *)// = sempre 4! sizeof(void *)// = sempre 4! sizeof(short[32])// = 64

30 C. Rocchini - C++30 Sizeof(2) struct registrazione { short x; bool b; double y; }; sizeof(registrazione) // >= sizeof(short)+sizeof(bool)+sizeof(double) // Attenzione! Puo essere anche maggiore per // motivi di allineamento del processore

31 C. Rocchini - C++31 La notte del C: le stringhe C // Prima nota: ogni volta che e possibile si usi il // tipo C++ std::string (e un oggetto) // Stringhe letterali: incluse in virgolette questa e una stringa // I caratteri invece sono inclusi in apici a // I vettori di caratteri possono essere interpretati // come stringhe, le stringhe sono terminate dal // carattere 0 char nome[100];

32 C. Rocchini - C++32 Stringhe C (2) char s[16] = casa;// Inizializzazione s[0]==c s[3]==a s[4]== 0// Terminazione della stringa s[5]== ??? Valore non Definito ??? char n1[4] = casa;// Errore: manca spazio char n2[5] = casa;// OK: corretto sizeof(casa)==5// 4 lettere + terminatore // Stringha nulla: char nulla[1000] = ; nulla[0] == 0// Subito il terminatore

33 C. Rocchini - C++33 String C (3) // I puntatori a carattere possono essere associati // a stringhe (puntatori al primo carattere). char * p = cavallo;// Stringa costante ! char x = p[2];// OK: lettura di v p[3] = i;// Errore: stringa costante char str[32] = cavallo;// Stringa variabile p = str;// p punta allinizio di str p[3] = i;// OK: str = cavillo

34 C. Rocchini - C++34 Stringhe C: funzioni // Funzioni della libreria string.h int strlen( char * str);// Lunghezza di una stringa str1 = str2;// Errore! strcpy( str1, str2 )// Copia di stringhe strcat( str1, str2 )// Concatenzazione str1 == str2// Errore! Conf. Puntatori! strcmp( str1, str2 )// Confronto fra stringhe strchr( str1, char )// Cerca un carattere strstr( str1, str2 )// Cerca una sottostringa // Altre funzioni: tokenizzatore (parser) strtok( str1, separatori)

35 C. Rocchini - C++35 Stringhe, per finire: escape seq. \// Virgolette nelle stringhe \// Il carattere apicetto \n// Ritorno a capo \r// Ritorno carrello \t// Carattere di tabulazione \\// Caratte barra rovesciata

36 C. Rocchini - C – Espressioni ed Istruzioni

37 C. Rocchini - C++37 Riepilogo operatori A = 3;// Assegnamento a variabile // Aritmetica di base A = b+c;// Somma A = b-c;// Sottrazione A = b*c;// Prodotto A = b/c;// Divisione A = b%c;// Resto della divisione intera A = -b;// Cambio di segno A = ((b+c)*d)-h;// Parentesi (solo tonde!)

38 C. Rocchini - C++38 Riepilogo operatori // Confronti e operatori logici if( A==B )..// Uguale A != B// Diverso A < B// Minore A > B// Maggiore A <= B// Minore o uguale A >= B// Maggiore o uguale &&// And (e) logico ||// Or (o) logico !// Not (non) logico // es. if( a max) …

39 C. Rocchini - C++39 Riepilogo operatori // Incrementi e decrementi int a = 2, b=7; ++a;// Incremento: a vale 3 --b;// Decremento: b vale 6 int x = 10; int y = x++;// Postincremento, x=11 ma y=10 int z = ++x;// Preincremento, z=12 e x = 12 int h = 42; int k = h--; // Postdecremento, h=41 ma k=42 // Utilizzabile sugli interi, non su virgola mobile

40 C. Rocchini - C++40 Operatori sui bit A = b & c;// And bit a bit A = b | c;// Or bit a bit A = b ^ c;// Xor = or esclusivo, 1 se b!=c A = ~b;// Not logico A = b<<3;// Shift a sinistra (di 3) A = b>>4;// Shift a destra // Esempi (b>>2)&1// Estrazione del terzo bit b|(1<<4)// Forza a uno il quarto bit b&~(1<<4)// Forza a zero il quarto bit (b>>8)&0xFF// Parte alta di una word <<2

41 C. Rocchini - C++41 Modificatori e Exp Condizionale // Modificatori A += b;// Scrittura riassuntiva di A = A + b; A -= b; A *= b; … A <<= 3;// Equivale a A = A << 3; // Espressione condizionale // condizione ? valore_se_vero : valore_se_falso A = b==0 ? 1 : 100/b; // se b vale 0 a prende 1 altrimenti prende 100/b // Corrisponde al se(;;) di Excel

42 C. Rocchini - C++42 Ordine di valutazione A = 3+2*3;// 9, non 15! (Anche in Basic) Record * p; *p.valore// Contenuto di valore (*p).valore// Contenuto di p if( a&b==0 ) // == associa prima di &: errato! if( (a&b)==0 ) // Corretto // Nel dubbio usare le parentesi! // Controllare la precedenza sul manuale

43 C. Rocchini - C++43 Memoria dinamica: new, delete int *p = 0;// Puntatore nullo *p = 7;// Errato: non esiste la locazione p = new int;// Allocazione di un intero *p = 7;// Corretto delete p;// Obbligatorio dopo lutilizzo! *p = 7;// Di nuovo errato double * v = 0; v = new double[1024];// Allocazione di un vettore v[907] = 3.14;// OK: memoria allocata … delete[] v;// Disallocazione: notare le []

44 C. Rocchini - C++44 Cast: Conversioni di tipo int a = 3; double x = a;// Automatica a = int(x);// Cast (troncamento) int * q; char * p = (char *)q;// Conversione di puntatore void * k;// Puntatore generico bool * b = (bool *)k; char c = char(3.14);// Da double a char

45 C. Rocchini - C++45 Istruzione condizionale if (a>b)// Parentesi () obbligatorie!! c = a;// Spaziatura non significativa! if (a!=b)// Blocco di istruzioni { c = a; b = a; } if (a>b) c = a;// Utilizzo di else else c = b;

46 C. Rocchini - C++46 Case switch(a)// A seconda del valore di a { case 1:// case + valore // se a=1 break;// Fine case case 2:// Doppio valore case 3: // se a=2 oppure 3 break; default:// Caso di default(case else) // Altrimenti… }

47 C. Rocchini - C++47 Cicli while while( a>b )// Ciclo while {// Controllo allinizio --a; } do// Ciclo do-while {// Controllo alla fine --a; } while( a>b );

48 C. Rocchini - C++48 Ciclo For // for(inizializzazione;condizione;iterazione) {} for(a=1;a<=10;++a)// Ciclo classico { // … } for(a=1; a<=100 ;a+=10)// step di 10 for(a=1024; a>1; a/=2)// Ciclo logaritmico //Struttura scansione di un file: //for(apri_file;not eof;leggi_carattere) // TODO FARE ESEMPIO

49 C. Rocchini - C++49 Esempio for su file FILE * fp; char c; for(fp=fopen(file);!EOF(fp);c=fgetc(fp)) { usa il carattare c }

50 C. Rocchini - C++50 goto //Il comando goto si articola in due parti: //Dichiarazione di una etichetta // Comando goto per saltarci. //Si usa raramente: in caso di errore per saltare //Fuori da una procedure (bisognerebbe usare le // Eccezioni //… goto etichetta; //.. etichetta: //…

51 C. Rocchini - C Funzioni

52 C. Rocchini - C++52 Funzioni: Introduzione // tipo_ritorno nome_funzione ( parametri … ); double sqrt( double x );// Dichiaraz. di prototipo double sqrt( double );// Altra dichiarazione double z = sqrt(2);// Utilizzo (chiamata) double y = sqrt(pippo);// Errore di tipo // Definizione di una funzione double doppio( double x )// Intestazione {// Inizio blocco return x*2;// Valore ritornato }// Fine blocco

53 C. Rocchini - C++53 Confronto C++ - Basic // C++ double prodotto( int x, int y ) { return x*y; } Basic Function prodotto(ByVal x,y As Integer) As Double prodotto = x * y End Function

54 C. Rocchini - C++54 Procedure e Riferimenti void scambia( int & a, int & b )// void = sub { int t = a; a = b; b = t; }// & = byreference In basic Sub scambia(ByRef a, b As Integer) Dim t As Integer t = a a = b b = t End Sub

55 C. Rocchini - C++55 Utilizzo di return nelle procedure // il comando return senza valore puo essere // utilizzato per uscire subito da una procedura void procedura() { //… if(voglio_terminare) return;// Esco subito // … // Fine naturale della procedura }

56 C. Rocchini - C++56 Inline e ricorsione // inline = consiglio al compilatore, per funzioni // piccole e semplici: programma piu veloce inline int fattoriale( int n ) { return n<2 ? 1 : n*fattoriale(n-1); } long fibonacci( long n ) { return n<3 ? 1 : fibonacci(n-1)*fibonacci(n-2); }

57 C. Rocchini - C++57 Variabili statiche void proc( int x ) { int a = 0;// Semplice variabile locale a += x;// Ricreata ad ogni chiamata printf(%d\n,a); } void proc( int x ) { static int a = 0;// Variabile statica persistente a += x;// Memorizza la somma degli x printf(%d\n,a); }

58 C. Rocchini - C++58 Variabili Statiche: Caso concreto // Procedura che necessita di una inizializzazione // complessa dei dati (da fare una volta sola): void operazione( char c ) { static bool prima_chiamata = true; if(prima_chiamata) { // … Inizializzazione … prima_chiamata = false; } // … operazione su c … }

59 C. Rocchini - C++59 Argomenti vettore // I vettori sono sempre passati by reference // Non possono essere valori di ritorno di funzioni int modifica( double v[1000] ) { v[3] = 7;// modifico il vettore passato } // Non e obbligatorio specificare la dimensione int modi( double v[] )… double v1[32]; double v2[1024]; modi(v1); modi(v2); // Per le matrici e obbligatorio specificare solo // la seconda dimensione double determinante( double M[][16] )…

60 C. Rocchini - C++60 Sovraccarico di nomi // E possibile dare lo stesso nome a varie funzioni void stampa( int x )// Funzione stampa { printf(%d\n,x); } void stampa( double x )// Unaltra funzione stampa { printf(%g\n,x); } int k = 3; stampa(k);// Chiama la prima funzione double h = 3.9; stampa(h);// Chiama la seconda

61 C. Rocchini - C++61 Sovraccarico: ambiguità int f( int x ) { return x*2; } double f( int x ) { return x*3; } int k = 9; f(k);// Errore: ambiguo! // Le funzioni sono distinte dai parametri ma non // dal tipo di ritorno!

62 C. Rocchini - C++62 Argomenti di default // E possibile specificare i valori di default // degli argomenti di una fuzione void stampa( char * str, int dimensione = 16) { // … } stampa(pippo,4);// Ok: dimensione = 4 Stampa(pluto);// OK: dimensione = 16 void f( int a = 3, int b )// Errore! // Si puo specificare solo gli ultimi valori!

63 C. Rocchini - C++63 Argomenti Costanti // Sara importantissimo nei membri di classe // Scrivetelo tutte le volte che e possibile void funzione ( const int a ) { int b = a;// OK: lettura valore a += 3;// Errore: modifca di a } // Il passaggio per valore copia i dati void stampa_stringa( std::string str ) … // Il reference evita la copia dei dati // Il const impedisce modifiche erronee void stampa_stringa( const std::string & str ) …

64 C. Rocchini - C++64 7b – Il Preprocessore

65 C. Rocchini - C++65 Inclusione di file // Il preprocessore e un programma a parte // Esegue modifiche sul testo tramite semplici // comandi prima che il file sia compilato // Le istruzione del prep. Iniziano sempre con # // Il comando #include copia un file testo nel // punto indicato #include // Inclusione di file di libreria #include mio.h// Inclusione di file locale

66 C. Rocchini - C++66 Macro // Il comando #define esegue una riscrittura #define K a+K a // Puo avere parametri #define somma(x,y) x+y somma(3,4) 3+4 somma(3,5)*6 3+5*6 #define PI // ma e meglio: in questo caso ha un tipo const double PI = ; #undef PI// Cancella la definizione #define VALORE// Definito a vuoto ma valido

67 C. Rocchini - C++67 Compilazione condizionale // Il comando #ifdef permette di considerare o no // alcune parti di testo. Esiste anche #ifndef #ifdef SINGOLA_PRECISIONE// Inizio IF float v[32]; float x; #else// Else double v[32]; double x; #endif// Fine IF x = v[7];// float o double

68 C. Rocchini - C++68 Compilazione Cond: caso tipico // Trucco per includere una sola volta lheader // di una libreria: #ifndef __MIA__LIBRERIA__ #define __MIA__LIBRERIA__ int mia_funzione( int x ); //… codice header #endif

69 C. Rocchini - C Namespace

70 C. Rocchini - C++70 Introduzione // I namespace permettono di rendere modulare il // codice definendo delle librerie: namespace mia_lib// Inizio libreria { int var = 5;// Def. Di variabile int fun( int x );// Definizione di funzione }// Fine libreria var = 6;// Errore: variabile non definita! mia_lib::var = 6;// OK mia_lib::fun(5); // Nota: in basic al posto di :: si usa il punto

71 C. Rocchini - C++71 Namespace: continua // Using permette di omettere il nome della libreria // (Simile al with sui record del basic using namespace mia_lib; var = 6;// OK: var e nella libreria mia_lib // std e la libreria standard del C++ std::string s;// string fa parte di std using namespace std; string s2;// OK: utilizzo la libreria std

72 C. Rocchini - C++72 X1 - Una libreria: stdio

73 C. Rocchini - C++73 Librerie Il c/c++ interagisce con il mondo tramite librerie. Se si vuole leggere la tastiera, aprire una finestra, leggere e scrivere un file, suonare, utilizzare la rete o i database, si devono utilizzare librerie aggiuntive. Le librerie sono decime di migliaia. Le librerie sono formate da funzioni e strutture dati. Ne vedremo una per lutilizzo di file: stdio. Ci sono anche io-> a bassissimo livello streams-> ad altissimo livello

74 C. Rocchini - C++74 Lettura Binaria #include // Inclusione header di stdio int main() { FILE * fp;// Descrittore di file (solo *!) // Apertura in lettura di un file fp = fopen(c:/temp/prova.txt,rb); MioDato d[3]; // Lettura binaria di un dato int r = fread(d,3,sizeof(MioDato),fp); if(r==0)… END OF FILE… fclose(fp);// Chiusura file return 0; }

75 C. Rocchini - C++75 Scrittura Binaria #include // Inclusione header di stdio int main() { FILE * fp;// Descrittore di file (solo *!) // Apertura in scrittura di un file fp = fopen(c:/temp/prova.txt,wb); if(fp==0) … errore… double v; // Scrittura binaria di un dato (Nota la &) fwrite(&d,1,sizeof(MioDato),fp); fclose(fp);// Chiusura file return 0; }

76 C. Rocchini - C++76 Scrittura testuale FILE * fp = fopen(prova.txt,w); fputc(c,fp);// Scrittura di un carattere fputs(cavallo,fp);// Scrittura di stringa fputc(\n,fp);// Ritorno a capo // Esempi di scrittura formatta // Vedere il manuale! fprintf(fp,%d %g,3,9.7); fprintf(fp,%s %30.20f,stringa,valore_num); fprintf(fp,%X \n,numero_ex); fclose(fp);

77 C. Rocchini - C++77 Lettura testuale FILE * fp = fopen(prova.txt,w); int c = fgetc(c,fp);// Lettura di un carattere if(c==EOF) … END OF FILE… char buf[MAX]; fgets(buf,MAX,fp);// Lettura di una riga! // Esempi di Lettura formatta // Notare la &: parametri puntatore! fscanf(fp,%d %g,&v1,&v2); fscanf(fp,%30.20f,&valore_num); fscanf(fp,%X,&numero_ex); fclose(fp);

78 C. Rocchini - C++78 Accesso Libero (Random) // Posizione corrente nel file (in byte!) long l = ftell(fp); // Spostamento al 42esimo byte del file fseek(fp,SEEK_SET,42); // Avanzamento di 80 byte fseek(fp,SEEK_CUR,80); // Spostamento al 42esimo byte della FINE del file fseek(fp,SEEK_END,42);

79 C. Rocchini - C++79 Input/output // Nella applicazioni console, esistono sempre due // file automaticamente aperti: // stdin in lettura = tastiera // stdout in scrittura = schermo // (In realta sono 3: esiste anche stderr…) fprintf(stdout,Buongiorno\n); int c = fgetc(stdin);// Legge da tastiera // Per ogni funzione esiste la versione compatta // senza file parametro e senza f nel nome: printf(Buongiorno\n);// su stdout int c = getc();// da stdin scanf(%d,&x);// Legge da stdin

80 C. Rocchini - C++80 Stdio: Per finire // scanf e printf esistono in versione stringa: char buf[1024]; sprintf(buf,numeri: %g %d\n, 3.5, 9 ); … sscanf(buf,%x%s,…); // La scrittura su disco e spesso bufferizzata // (vale a dire ritardata) per motivi di efficienza // fflush costringe il sistema ad effettuare // immediatamente una scrittura fisica: fflush(fp);

81 C. Rocchini - C – Puntatori e Vettori

82 C. Rocchini - C++82 I puntatori La variabili sono allocate in memoria, le zone di memoria sono indirizzabili da indirizzi numerici. I Puntatori sono indirizzi di memoria. (* = puntatore) ( & = indirizzo ) std::string pippo = Claudio; std::string * ptr = &pippo; Claudio pippo: Indirizzo di pippo ptr:

83 C. Rocchini - C++83 Puntatore nullo ed Esempi // Il puntatore nullo e rappresentato dal valore 0 // Corrisponde al nothing del Basic char * p = 0;// Valore nullo int * p;// Puntatore ad un intero int **q;// Puntatore ad un puntatore ad un intero int * v[32];// Vettore di 32 puntatori ad intero void * z;// Puntatore senza tipo z = p;// OK: da tipo a senza tipo p = z;// Errore: specifica di tipo! P = (int *)z;// OK: conversione esplicita di tipo

84 C. Rocchini - C++84 Inizializzazione di vettori // E possibile inizializzare i vettori direttamente int v[4] = {3,91,23,4}; char k[3] = { a,b,c }; double m[2][2] = { {1,2}, {3,4} }; int w[] = {3,6,7,8};// Lunghezza implicita

85 C. Rocchini - C++85 Puntatori e vettori int v[20]; int * p = v;// Il nome di un vettore e il puntatore al // Primo elemento int * w = v+7;// Puntatore allottavo elemento (0=primo) // Scorrimento di un vettore con indice intero int i; for(i=0;i<20;++i) printf(%d,v[i]); // Scorrimento di un vettore con puntatore (piu veloce!) int * j; for(j=v;j

86 C. Rocchini - C – Sorgenti e programmi

87 C. Rocchini - C++87 Moduli Un programma di medie dimensioni non e mai scritto in un unico sorgente.c++ I programmi sono suddivisi in moduli, cioe in file separati. La separazione dipende dalla logica del programma (oggetti separati in file separati). E possibile compilare separatamente i vari moduli. Le modifiche di un modulo in genere non interferiscono con gli altri. Gruppi di moduli comuni sono raccolti in librerie.

88 C. Rocchini - C++88 Header e Sorgenti Ad un modulo (file.c++) che esporta simboli e associato un file di intestazione (header.h) Lheader contiene la specifica dei simboli esportati. Le librerie standard (stdio,vector,stdlib) sono formati da moduli in forma di librerie + header da includere con il comando #include

89 C. Rocchini - C++89 Variabili e funzioni locali // Di default, variabili e funzioni vengono // esportate dal modulo. int pippo;// Variabile esportata void mia_funzione( int x )// Funz. esportata { … } // Gli oggetti dichiarati static invece non // vengono esportati static int pluto;// Privata del modulo static void altra_funzione( int x ); // Privata

90 C. Rocchini - C++90 Creazione dellheader // File mio.c++ //Per essere utilizzati, //i simboli esportati //devono essere dichiarati //nellheader int pippo; void funzione( int x ) { … } // File mio.h //Per distinguerla da una //dichiarazione, la def. //della variabile deve //essere preceduta da //extern. extern int pippo; //Per le funzioni si //scrive il prototipo void funzione( int x );

91 C. Rocchini - C++91 Schema di utilizzo // file: mio.h void funzione(int x); // file: main.c++ // Inclusione header #include mio.h void main() { // Utilizzo delle funz. funzione(3); } // file: mio.c++ static int y = 42; void funzione(int x) { printf(%d,x+y); }

92 C. Rocchini - C++92 Cosa si mette nellheader? // Define #define PI // Prototipi di funzione esportate void funzione(int x); // Def. Variabili esportate extern bool pippo; // Implementazioni di funzioni inline!!!! inline int minimo(int x, int y) { return x

93 C. Rocchini - C++93 Protezione dalla doppia inclusione // Di solito includere due volte un header comporta // un errore; di solito di protegge gli header dalla // doppia inclusione nel seguente modo #ifndef __COSTANTE_DAL_NOME_VERAMENTE_STRANO__ #define __COSTANTE_DAL_NOME_VERAMENTE_STRANO__ // Corpo dellheader // … #endif

94 C. Rocchini - C – Classi !!!!!

95 C. Rocchini - C++95 Introduzione alle classi Le classi sono il vero cuore del C++ Permettono di utilizzare e definire oggetti Una classe definisce un nuovo tipo Una classe contiene dati e funzioni Ci sara molto altro da dire…

96 C. Rocchini - C++96 Utilizzo di una Classe (Oggetto) // std::string e un oggetto, non ha attributi, // ha solo membri. std::string str;// Dichiarazione di oggetto str = Claudio;// Assegnazione valore printf(%u\n, str.length() );// Chiamata membro str = str + Rocchini;// Espressione std::string x = str.substr(0,4);// Sottostringa

97 C. Rocchini - C++97 Esempio in C : data struct Data// Dati { int giorno,mese,anno; }; // Procedure void inizializza_data( data & d, int g, int m,int a ) { data.giorno = g; data.mese = m; data.anno = a; } // Utilizzo Data k; inizializza_data(k,28,6,1967);

98 C. Rocchini - C++98 Esempio in C (continua) void aggiungi_anni( Data & d, int anni ) { d.anno += anni; } // Notare il riferimento costante: // Evita la copia void stampa_data( const Data & d ) { printf(%02d/%02d/%d\n, d.giorno, d.mese, d.anno); } …

99 C. Rocchini - C++99 Stesso Esempio in C++ // Allinizio la definizione di classe sembra // una struttura class Data { int giorno,mese,anno; }; Data d;// Dichiarazione di variabile

100 C. Rocchini - C++100 Esempio (2): funzioni membro class Data// Dichiarazione di classe { int giorno,mese,anno;// Dati void aggiungi_anni( int anni );// Membro }; // Definizione classe membro void data::aggiungi_anni( int anni ) { anno += anni; } Data d; d.aggiungi_anni(3);// Chiamata del membro

101 C. Rocchini - C++101 Esempio (2): funzioni membro class Data// Dichiarazione di classe { int giorno,mese,anno;// Dati void aggiungi_anni( int anni );// Membro }; // Definizione classe membro void data::aggiungi_anni( int anni ) { anno += anni; } Data d; d.aggiungi_anni(3);// Chiamata del membro Riferimento allattributo Specifica di classe

102 C. Rocchini - C++102 Funzioni membro: string namespace std// Inizio namespace { class string// Inizio classe stringa { int length();// Funzione membro … };// Fine classe }// Fine namespace std::string str; int lunghezza = str.length();// Chiamata di membro

103 C. Rocchini - C++103 Controllo di Accesso class Data { private:// Dati e membri privati int giorno,mese anno; int mia_funzione(); public:// Dati e membri pubblici void stampa(); }; Data d; d.giorno = 3;// Errore: dato privato d.mia_funzione();// Errore: membro privato d.stampa();// OK: membro pubblico

104 C. Rocchini - C++104 Accesso e Membri class Data { private:// Dati e membri privati int giorno,mese anno; public:// Dati e membri pubblici void stampa(); }; void Data::stampa()// Def. della procedura { printf(%d\n,giorno);// OK: un membro puo sempre }// accedere ai dati della // sua classe!

105 C. Rocchini - C++105 Incapsulamento class pippo {..dati// Dati privati: default = privato public:// Zona pubblica void interfaccia1(); void interfaccia2(); }; // La protezione dellimplementazione e una delle // basi dellincapsulamento: nascondere // limplementazione permette di cambiarla in seguito. // Nota: esiste anche protected, lo vedremo in seguito

106 C. Rocchini - C++106 Costruttore // Il costruttore e una procedura chiamata // automaricamente alla creazione di un oggetto class Data { int giorno, mese, anno; public: Data();// Dichiarazione costruttore }; Data::Data()// Codice costruttore (non ha tipo) { giorno = 1; } Data d;// Chiama il costruttore (giorno=1)

107 C. Rocchini - C++107 Costruttore con Parametri class Data { int giorno,mese,anno;// Costruttori public: Data();// Default Data( int g, int m, int a );// Con parametri }; Data::Data() {}// Def. default Data::Data(int g, int m, int a)// Def. Con parametri { giorno=g; mese=m; anno=a; } Data d1;// Chiama il primo costruttore Data d2(28,6,1967);// Chiama il secondo costruttore

108 C. Rocchini - C++108 Distruttore // Il distruttore viene chiamato quando loggetto e distrutto class Oggetto { public: Oggetto();// Costruttore ~Oggetto();// Distruttore }; Oggetto:: Oggetto() { printf(Creazione\n); }// Dichi. Oggetto::~Oggetto() { printf(Distruzione\n); }// Dichi. if(true) { Oggetto x;// Loggetto e creato }// Fine blocco: loggetto e distrutto

109 C. Rocchini - C++109 Costruttore e distruttore class MioFile { public: FILE * fp; MioFile(); ~MioFile(); }; MioFile::MioFile() { fp = 0; }// Inizializzo a null // Chiusura automatica del file MioFile::~MioFile() { if(fp) fclose(fp); } MioFile f; f.fp = fopen(…);// Chiusura aut.

110 C. Rocchini - C++110 Dati di Classe Statici // I dati statici di classe sono UNICI per tutti gli // oggetti di quella classe class Oggetto { public: static int numero_oggetti;// Unico per tutta la classe Oggetto();// Costruttore }; // I dati di classe statici devono essere definiti: Oggetto::numero_oggetti = 0; Oggetto::Oggetto() { ++ numero_oggetti; } //Def. Costruttore Oggetto o1; printf(%d\n,o1.numero_oggetti);// -> 1 Oggetto o2,o3; printf(%d\n,o1.numero_oggetti);// -> 3

111 C. Rocchini - C++111 Funzioni Membro statiche // Le funzioni membro statiche non fanno riferimento ai // dati della classe (oppure solo ai dati statici). class Data { public: static std::string nome_classe();// Membro statico } std::string Data::nome_classe()// Def. Membro statico { return CLASSE DATA; } Data d; printf(%s\n,d.nome_classe());// Call oggetto printf(%s\n, Data::nome_classe() );// Call diretta

112 C. Rocchini - C++112 Funzioni Membro Costanti // I membri che non modificano i dati delloggetto devono // essere dichiarati costanti. class Data { int giorno,mese,anno; public: bool bisestile() const;// Membro costante } bool Data::bisestile() const// Definizione { return anno%4==0 && anno%100!=0;// Non modifica i dati // ++anno -> errore: modifica i dati }

113 C. Rocchini - C++113 Autoriferimento // this e il puntatore alloggetto corrente (me in VB) class NodoLista { public: NodoLista * successore; public: void link( NodoLista & n ); }; // Implementazione di link void NodoLista ::link( NodoLista & n ) { n.successore = this; }

114 C. Rocchini - C++114 Utilizzo dellAutoriferimento // Spesso e utile che un membro ritorni un // Riferiemtno alloggetto Data & Data::incrementa_giorno() { ++giorno;// Incrementa il giorno return *this;// Ritorna il rif. a se stesso } Data d; // Chiamata in cascata dei membri d. incrementa_giorno().stampa();

115 C. Rocchini - C++115 Definizioni Interne alla classe // Scrittura classica class Data { int g; public: int & giorno(); }; // Scrittura Compatta class Data { int g; public: int & giorno() { return g; } };

116 C. Rocchini - C++116 Direttiva inline // La direttiva inline deve essere usata per funzioni // semplici: modifica la tecnica di chiamata di // Procedura. Non puo essere usata per funzioni // Complesse inline int & Data::giorno() { return g; } // E una specifica di bassisimo livello come lo // era register. Forse verra eliminata

117 C. Rocchini - C++117 Sovraccarico degli Operatori // Si possono ridefinire gli operatori come funzioni // operator== e il nome della funzione inline bool operator== ( const Data & d1, const Data & d2 ) { return d1.g==d2.g && d1.m==d2.m && d1.a==d2.a; } inline bool operator!= ( const Data & d1, const Data & d2 ) { return d1.g!=d2.g || d1.m!=d2.m || d1.a!=d2.a; } if( data1 == data2 )…// Chiama la nostra funzione

118 C. Rocchini - C++118 Sovraccarico dei membri class Data { public: int g,m,a; Data & operator+= ( int ng ); }; // Implementazione del membro Data & Data::operator+= ( int ng ) {g += ng;// Modifica giorni return *this;// Ritorna il rif. a se stesso } Data d(3,12,2004); (d += 3).print();// 6/12/2004

119 C. Rocchini - C++119 Esempio concreto: un file come vettore di caratteri class VFile { private: FILE * fp; public: VFile() { fp = 0; } // Definizione abbreviata del costr. ~ VFile() { if(fp) fclose(fp); }// Chiusura autom. bool open(char * name ) { return ( fp=fopen(name,r) ); } char operator[] ( int p )// Op []! {fseek(fp,SEEK_SET,p); return fgetc(fp); } }; VFile ff; ff.open(prova); int x = ff[31];

120 C. Rocchini - C++120 Operatore in scrittura? class FileReference { private: long pos; FILE * fp; FileReference( long p, FILE * f ) { pos=p; fp=f;} FileReference & operator= ( char c ) { fseek(fp,SEEK_SET,pos); fwrite(&c,1,1,fp); return *this; } }; FileReference Vfile::operator[] ( long i ){ return FileReference(i,fp); } vf[42] = 5;

121 C. Rocchini - C++121 Operatore di Assegnamento // Ne viene creato uno di default che copia i dati // Ma e anche possibil riscrivero class Data {… Data & operator= ( const Data & d ); }; // Implementazione Data & Data::operator= ( const Data & d ) { g = d.g; m = d.m; a = d.a; return *this; } Data d1,d2,d3; d1 = d2 = d3;

122 C. Rocchini - C++122 Oggetti membro class Evento { public: Data d; std::string nome; // Costruttore con parametri di membri oggetto Evento( std::string n, int g, int m, int a ):d(g,m,a) { nome = n; } }; Evento e(nascita,28,6,1967);

123 C. Rocchini - C – Sovraccarico degli operatori

124 C. Rocchini - C++124 Introduzione Gli operatori simbolici operanti sugli oggetti possono essere ridefiniti. Questo vuol dire che posso chiamare una funzione con un simbolo di operatore.

125 C. Rocchini - C++125 Esempio: data ++ class data { public: int g,m,a; void operator++ () { if(++g==ultimo_giorno[m]){ g = 1; if(++m>12){ m = 1; ++a; } }; Data d; ++d;// Chiama la funzione operator

126 C. Rocchini - C++126 Esempio: confronto di date class Data { … // Operatore costante con parametro costante bool operator< ( const Data & d ) const { if(a!=d.a) return ad2 )..// Errore! > non definito (neanche di default)

127 C. Rocchini - C++127 Una semplice classe: Point2 // Definiremo la classe punto (o vettore bidimensionale) class Point2// Intestazione { private:// Dati privati double v[2];// Dati della classe: x,y public:// Membri pubblici //… membri … };// Notare il ;

128 C. Rocchini - C++128 Costruttori (Niente distruttore) inline Point2()// Costruttore di default { // Niente da fare (ma obbligatorio dichiarare la funzione) } inline Point2( double v0, double v1 ) { v[0] = v0;// Costruttore con v[1] = v1;// Inizializzazione } I costruttori sono chiamati automaticamente quando loggetto viene creato.

129 C. Rocchini - C++129 Operatore di assegnamento inline Point2 & operator= ( const Point2 & p ) { v[0] = p.v[0];// Copio x v[1] = p.v[1];// Copio y return *this; } Note: la stringa operator= è il nome della funzione. Mentre Point2 & e il tipo di ritorno. Il parametro e costante riferimento per evitare la copia. Il tipo del parametro è obbligatorio, come il valore di ritorno che permette di concatenare le espressioni: a = b = 3; infatti a = (ritorno di b=3);

130 C. Rocchini - C++130 Metodo somma inline Point2 operator+ (const Point2 & p) const { return Point2( v[0]+p.v[0], v[1]+p.v[1] ); } Note: il primo operando delloperatore somma è loggetto in questione (this). Loperatore è const (non modifica loggetto). Si utilizza il costruttore con parametri per costruire al volo il valore di ritorno. Il parametro p è passato per riferimento per motivi di efficienza. Il membro e costante: non modifica loggetto

131 C. Rocchini - C++131 Funzione di stampa inline void show() const { printf([%g,%g]\n,v[0],v[1]); } Metodo per la visualizzazione della classe; loggetto è visualizzato nella forma: [v0,v1].

132 C. Rocchini - C++132 Esempio di utilizzo int main() { Point2 a(2,4);// Costr. con iniziliz. Point2 b(3,2); Point2 c;// Costruttore default c = a+b;// Somma ed assegnamento c.show();// Visualizzazione return 0; } // Risultato: [5,6]

133 C. Rocchini - C++133 Membri di accesso ai dati // Versione costante inline const double & x() const { return v[0]; } inline const double & y() const { return v[1]; } // Versione non costante inline double & x() { return v[0]; } inline double & y() { return v[1]; } Point2 p1,p2; p1.v[0];// Errore dato privato K = p1.x();// OK: accesso costante p2.x() = 3;// OK: accesso non costante K = (p1+2).x(); // OK: accesso costante a temporaneo

134 C. Rocchini - C++134 Membri modificatori inline Point2 & operator+= ( Point2 const & p ) { v[0] += p.v[0]; v[1] += p.v[1]; return *this; } Nota: il membro non e costante, ritorna il riferimento a se stesso per operazioni in cascata, tipo: a = ( b+=c );

135 C. Rocchini - C++135 Ordinamento inline bool operator== ( const Point2& p ) const { return v[0]==p.v[0] && v[1]==p.v[1]; } inline bool operator!= ( const Point2& p ) const { return v[0]!=p.v[0] || v[1]!=p.v[1]; } inline bool operator< ( const Point2& p ) const { return v[1]!=p.v[1] ? (v[1]

136 C. Rocchini - C++136 Oggetti Funtori // Ridefinendo loperatore chiamata di funzione // (), e possibile creare oggetti che si // comportano come funzioni. class Doppiatore { public: double operator() ( double x ) { return x*2; } }; Doppiatore d; printf(%g, d(7) );// Stampa 14

137 C. Rocchini - C – Classi derivate

138 C. Rocchini - C++138 Derivazione // E possibile derivare una classe da unaltra // La nuova classe eredita tutti gli attributi class Point2 { public: double v[2]; }; class Punto_Colorato : public Point2 { public: Colore c; }; Punto_Colorato k; k.c = rosso;// Attributo della nuova classe k.v[0] = 3;// Eredita i metodo di Point2

139 C. Rocchini - C++139 Sovrascrittura di membri class Point2 { … void stampa(); } class Punto_Colorato : public Point2 { … void stampa();// Riscrive la funzione di Point2 }; Punto_Colorato p; p.stampa();// Chiama la riscritta void Punto_Colorato::stampa()// Implementazione { stampa_colore(c); Point2::stampa();// Invocazione funzione originale }

140 C. Rocchini - C++140 Puntatori a classi derivati // I puntatori a classi derivate sono interscambiabili Punto_Colorato pc; double k; Point2 * punt = &pc; // OK: classe padre Point2 * pun2 = &k; // Errore: double non deriva da P2 // I metodo da chiamare sono derivati dal tipo punt->stampa(); // Chiama il metodo di Point2 anche se loggetto e // un Punto_Colorato (non stampa il colore) pc.stampa();// Stampa il colore

141 C. Rocchini - C++141 Gerarchie di Classi ed Interfacce Le gerarchie di classi sono fondamentali nelle interfacce. OggettoGenerico –Finestra (.disegna) Controllo (.disegna,.evento) –Bottone (.evento) »BottoneRadio (.selezionato) »BottoneCheck (.stato) »BottoneComando (.evento) –Lista –CampoTesto (.valore) FinestraCornice –DocumentoSingolo –MultiDocumento

142 C. Rocchini - C++142 Gerarchie esempio MFC

143 C. Rocchini - C++143 Metodi virtuali // Per fare in modo che il metodo non dipenda dal tipo // ma dalloggetto nelluso di puntatori si usa: class Point2 { public: virtual stampa(); }; Punto_Colorato pc; Point2 * punt = &pc; punt->stampa(); // Chiama Punto_Colorato perche virtual

144 C. Rocchini - C++144 Note a Virtual Nel Basic tutti i metodo sono virtual. Nel c++ si e deciso di rendere virtual alcuni metodo esplicitamente, perché questo rende leggermente più lento il programma: infatti questo è lunico caso che comporta un controllo di tipo durante lesecuzione del programma. Daltro canto il meccanismo è indispensabile, soprattutto nelle interfacce grafiche.

145 C. Rocchini - C++145 Classi astratte // E possibile definire membri puramente virtuali che // definiscono classi astratte. In Java si chiamano // interfacce. class PuntoAstratto { public: virtual void stampa() = 0;// =0 -> virtuale pura }; PuntoAstratto p;// ERRORE: classe astratta class PuntoReale { public: virtual void stampa();// OK: definisce stampa in concreto }

146 C. Rocchini - C Template La vera potenza del C++ !

147 C. Rocchini - C++147 Introduzione ai Template 1 Supponiamo di voler realizzare la funzione minimo di due interi: inline int minimo( int a, int b ) { if(a

148 C. Rocchini - C++148 Introduzione ai Template 2 Adesso voglio il minimo fra due double: inline double minimo( double a, double b ) { if(a

149 C. Rocchini - C++149 Introduzione ai Template 3 In C++ e possibile passare un tipo come parametro ad una funzione (o ad una classe): template // T e il parametro tipo inline T minimo( T a, T b ) { if(a

150 C. Rocchini - C++150 Nota Implementativa I template sono parametri di tipo tipo Sono realizzati con la massima efficienza (nessun controllo al tempo di esecuzione). Permettono di creare classi od algoritmi generici, non dipendenti dal tipo dei dati. Esempi tipici: algoritmo di ordinamento di un vettore. Contenitori senza tipo. Il C++ e lunico linguaggio di programmazione che ha i template. I template sono la base costruttiva della Libreria Standard.

151 C. Rocchini - C++151 Classi Template // Es. Posso definire la classe Punto senza // Specificare il tipo delle coordinate template class Point2 { public: S v[2]; }; Point2 p1; // Punto doppia precisione Point2 p2; // Punto singola precisione Point2 p3; // Punto intero

152 C. Rocchini - C++152 Esempio template! Es1: point –Consultate i lucidi relativi alla esercitazione 1: classe point Es2: vector –Consultate i lucidi relativi alla esercitazione 2: classe vector

153 C. Rocchini - C Libreria Standard

154 C. Rocchini - C++154 Introduzione alla STL La libreria standard e uno dei punti più alti dellinformatica. Raccoglie i risultati teorici dellinformatica sugli algoritmi e le strutture dati creati nel corso degli anni. Se ho bisogno di un algoritmo, e probabile che ci sia gia scritto nella STL. Ogni elemento dellSTL e realizzato con la massima efficienza.

155 C. Rocchini - C++155 Stringhe Il C++ non ha il tipo stringa come oggetto base; la libreria standard introduce logggetto string: std::string str = Pippo; int l = str.length(); // Tutta la libreria standard e contenuta // nel namespace std. Ovviamente e possibile // utilizzare: using namespace std;

156 C. Rocchini - C++156 STL - Contenitori I contenitori sono oggetti che contengono altri oggetti. Ogni contenitore ha le proprie caratteristiche. I contenitori comprendono: vector, list, map, set, deque, stack, heap. I contenitori sono template sul tipo di oggetto contenuto.

157 C. Rocchini - C++157 STL - iteratori Ad ogni contenitore e associato il proprio oggetto iteratore. Literatore serve per scorrere gli elementi di un contenitore (e una estensione del puntatore, vale a dire che un iteratore punta ad un elemento dentro il contenitore).

158 C. Rocchini - C++158 Vector // vector introduce i vettori dinamici non presenti nel // C++ base. // Vector ha un parametro template sul tipo Contenuto: vector v; v.resize(1000); v[999] = 3; vector d;// Vettore di date // d.front() : primo elemento |d.begin() : it inizio // d.back() : ultimo elemento|d.end() : it fine // Scansione: vector ::iterator i;// iteratore associato for(i=d.begin();i!=d.end();++i) i->stampa();// si usa come un puntatore

159 C. Rocchini - C++159 List List implementa le liste di oggetti. List non ha loperatore [] (non e possibile indirizzare lennesiomo elemento), ma linserimento e lestrazione di un elemento sono molto veloci. list l;// Lista di valori l.push_front(9);// Inserimento in testa l.push_back(11);// Inserimento in coda list ::iterator i;// iteratore associato for(i=l.begin();i!=d.end();++i) printf(%g,*i); // si usa come un puntatore // Nota la scansione e identica al vettore

160 C. Rocchini - C++160 Map Map e un contenitore molto potente: implementa un vettore autoassociativo, vale a dire un oggetto che assomiglia ad un vettore, ma utilizza come indice un qualsiasi altro oggetto (E implementato con un B*-albero red/black). Map e un template con due parametri: oggetto indice e oggetto contenuto. map eventi; // Da date a stringhe eventi[ Data(28,6,1967) ] = Compleanno; string s = eventi[Data(28,6,1967)];

161 C. Rocchini - C++161 Altri contenitori deque e una coda (chi primo arriva, primo e servito). stack e una pila (per chi sa a cosa serve). heap e una coda con priorita, vale a dire che e una coda con qualcuno raccomandato. set e un contenitore insieme (in senso matematico) Tutti hanno i propri iteratori.

162 C. Rocchini - C++162 Algoritmi di ricerca 1.for_each Applica un operatore ad ogni elem. 2.find Cerca un elemento 3.find_if Cerca secondo una condizione 4.adjacent_find Prima coppia di uguale consecutivi 5.find_first_of Cerca un elemento da un insieme 6.count Conta gli elementi 7.count_if Conta secondo una condizione 8.mismatch Primo elemento diverso fra due ins. 9.equal Controllo luguaglianza 10.search Cerca sottosequenza 11.search_n Cerca n elementi uguali 12.find_endCerca a partire dalla fine

163 C. Rocchini - C++163 Algoritmi di Modifica copy Copia di elemeni swap Scambia due elementi replace Rimpiazza un elemento con un altro replace_if … con una condizione fill Riempie con un valore generate Riempie con una funzione remove Rimuove un valore remove_if.. Secondo una condizione unique Toglie gli elementi duplicati !! reverse Inverte lordine rotate Ruota lordine random_shuffle Mescolamento Casuale (*SGI ext.*)

164 C. Rocchini - C++164 Ordinamenti sortordinamento! Spesso si usano oggetti funtori per comparare gli oggetti lower_boundricerca binaria O(log(n)) upper_bound Ci sono molte altre cose (funtori), ma per ora non le vedremo.

165 C. Rocchini - C++165 Interfacce grafiche Es3: mfc –Consultate i lucidi relativi alla esercitazione 3: applicazione grafica con Microsoft Foundation Classes

166 C. Rocchini - C++166 Esercitazioni ed Esempi Manipolazione di testi Database (odbc o MySql) Libtiff Cenni ad OpenGL

167 C. Rocchini - C++167 Argomenti avanzati del C++ Parametri non specificati Eccezioni Puntatori a funzioni Cast specificati Mutable Problemi dellereditarieta multipla


Scaricare ppt "C. Rocchini - C++1 C/C++ Claudio Rocchini IGM. C. Rocchini - C++2 -1 Pre Introduzione."

Presentazioni simili


Annunci Google