C/C++

C. Rocchini - C++ 1

C/C++

Claudio Rocchini

IGM

C. Rocchini - C++ 2

-1 Pre Introduzione

C. Rocchini - C++ 3

Il C/C++

• Il C++ e’ un linguaggio di programmazione.• E’ il lunguaggio utilizzato per creare i

programmi (insieme all’Assembler), (es. Windows, Linux, Office, OpenOffice, Apache, Perl, PHP, Oracle, PostgreSql, AdobePhotoshop, etc. sono scritti un C/C++)

• L’efficienza 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).

C. Rocchini - C++ 4

0 - Introduzione

C. Rocchini - C++ 5

Il Mio primo programma

#include <stdio.h> //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 {}

C. Rocchini - C++ 6

Struttura

TipoRisultato NomeFunzione( Parametri)

{

istruzione;

istruzione;

…

return valore_ritorno;

}

Altra_Funzione …

// Commento di una linea

/* Commento di piu’

linee */

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.

C. Rocchini - C++ 8

Nota sullo stile 2

• Esiste un campionato mondiale di C scritto disordinato: “The International Obfuscated C Code Contest”, http://www.ioccc.org/

• Uno dei vincitori:

main() { printf(&WIN32["\021%six\012\0"],(WIN32)["have"]+"fun"-0x60);}

http://www.ioccc.org/

http://www.ioccc.org/

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(){

_-_-_-_ _-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_ _-_-_-_

}

C. Rocchini - C++ 10

Esercitazione

• Es0: applicazione console• Consultate i lucidi relativi alla esercitazione 0: applicazione console


4 – Tipi Fondamentali


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)


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)


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


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!


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


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


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.


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!


Introduzione ai puntatori

int a = 5; // Una variabile intera

int *p = &a;

// p è un puntatore a intero,

// viene assegnato all’indirizzo

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

…


Costanti

const double PI = 3.141596; // 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


Vettori Statici

char v[10]; // Vettore di 10 elemeni (da 0 a 9)

int x;v[7] = 11; // Accesso ad un elementov[999] = 1; // Errore catastrofico!

// Forse distruggi xdouble mat[3][3]; // Vettore bidimensionalemat[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, dinamicoconst int b = 10; char x[b]; // Ok, statico


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


Regole di Visibilità

int x = 1; // Globale al modulo

void sub(){

x = 7; // Modifico la globaleint x = 2; // Locale alla procedura…{ int x = 3; // Locale al sottoblocco

// Qui x vale 3int y = 99;

}// Qui y non e’ dichiarata!

}


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;


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;


Strutture 2

struct Dipendente

{

string nome;

string cognome;

int eta;

};

…

Dipendete d1,d2;

d1.nome = “claudio”;

d1.eta = 37;

d2.nome = “claudia”;


Puntatore a Strutture

struct Registrazione // Dichierazione di tipo{

bool ok;int valore;double x;

}; // Notare il punto e virgolaRegistrazione a; // Una strutturaRegistrazione * p = &a; // Puntatore a strutturaa.valore = 5;(*p).valore = 3; // Accesso ai campip->valore = 7; // Altra scrittura

Registrazione k = {false,3,0.9}; // Inizializzazione


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


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


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


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


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 all’inizio di str

p[3] = ‘i’; // OK: str = “cavillo”


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”)


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


6 – Espressioni ed Istruzioni


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!)


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<min || a>max) …


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


Operatori sui bit

A = b & c; // And bit a bitA = b | c; // Or bit a bitA = b ^ c; // Xor = or esclusivo, 1 se b!=cA = ~b; // Not logicoA = b<<3;// Shift a sinistra (di 3)A = b>>4;// Shift a destra

// Esempi(b>>2)&1 // Estrazione del terzo bitb|(1<<4) // Forza a uno il quarto bitb&~(1<<4)// Forza a zero il quarto bit(b>>8)&0xFF // Parte alta di una word

1 0 1 0 1 1 1 0 1 0 1 1 1 0 0 0<<2


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


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


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 l’utilizzo!

*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 []


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


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;


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…

}


Cicli while

while( a>b ) // Ciclo while

{ // Controllo all’inizio

--a;

}

do // Ciclo do-while

{ // Controllo alla fine

--a;

} while( a>b );


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


Esempio for su file

FILE * fp;

char c;

for(fp=fopen(file);!EOF(fp);c=fgetc(fp))

{

usa il carattare c

}


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:

//…


7- Funzioni


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


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


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 = tEnd Sub


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”

}


“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);

}


Variabili statiche

void proc( int x ){

int a = 0; // Semplice variabile localea += x; // Ricreata ad ogni chiamataprintf(“%d\n”,a);

}

void proc( int x ){

static int a = 0; // Variabile statica “persistente”a += x; // Memorizza la somma degli xprintf(“%d\n”,a);

}


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 …

}


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 dimensioneint 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] )…


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 ) // Un’altra funzione stampa

{

printf(“%g\n”,x);

}

int k = 3; stampa(k); // Chiama la prima funzione

double h = 3.9; stampa(h); // Chiama la seconda


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!


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!


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 ) …


7b – Il Preprocessore


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 <stdio.h> // Inclusione di file di libreria

#include “mio.h” // Inclusione di file locale


Macro

// Il comando #define esegue una riscrittura

#define K 12345

a+K a+12456

// Puo’ avere parametri

#define somma(x,y) x+y

somma(3,4) 3+4

somma(3,5)*6 3+5*6

#define PI 3.1415926

// ma e’ meglio: in questo caso ha un tipo

const double PI = 3.1415926;

#undef PI // Cancella la definizione

#define VALORE // Definito a vuoto ma valido


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


Compilazione Cond: caso tipico

// Trucco per includere una sola volta l’header

// di una libreria:

#ifndef __MIA__LIBRERIA__

#define __MIA__LIBRERIA__

int mia_funzione( int x );

//… codice header

#endif


8 - Namespace


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


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


X1 - Una libreria: stdio


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 l’utilizzo di file: stdio.

Ci sono anche

io-> a bassissimo livello

streams-> ad altissimo livello


Lettura Binaria

#include <stdio.h> // Inclusione header di stdioint 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 datoint r = fread(d,3,sizeof(MioDato),fp);if(r==0) … END OF FILE…fclose(fp); // Chiusura filereturn 0;

}


Scrittura Binaria

#include <stdio.h> // Inclusione header di stdioint 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 filereturn 0;

}


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


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


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


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


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


5 – Puntatori e Vettori


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 pippoptr:


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


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


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 all’ottavo 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<v+20;++j)

printf(“%d “,*j); // *j = contenuto di j


9 – Sorgenti e programmi


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.


Header e Sorgenti

• Ad un modulo (file .c++) che esporta simboli e’ associato un file di intestazione (header .h)

• L’header 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


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


Creazione dell’header

// File mio.c++

//Per essere utilizzati,

//i simboli esportati

//devono essere dichiarati

//nell’header

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


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

}


Cosa si mette nell’header?

// Define

#define PI 3.1415296

// 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<y ? x : y;

}


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 dell’header

// …

#endif


10 – Classi !!!!!


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…


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


Esempio in C : datastruct 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);


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

}

…


Stesso Esempio in C++

// All’inizio la definizione di classe sembra

// una struttura

class Data

{

int giorno,mese,anno;

};

Data d; // Dichiarazione di variabile


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


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 all’attributo

Specifica di classe


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


Controllo di Accesso

class Data{private: // Dati e membri privati

int giorno,mese anno;int mia_funzione();

public: // Dati e membri pubblicivoid stampa();

};

Data d;d.giorno = 3; // Errore: dato privatod.mia_funzione(); // Errore: membro privatod.stampa(); // OK: membro pubblico


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!


Incapsulamento

class pippo{

..dati // Dati privati: default = privatopublic: // Zona pubblica

void interfaccia1();void interfaccia2();

};

// La protezione dell’implementazione e’ una delle// basi dell’incapsulamento: nascondere// l’implementazione permette di cambiarla in seguito.

// Nota: esiste anche protected, lo vedremo in seguito


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)


Costruttore con Parametri

class Data{

int giorno,mese,anno; // Costruttoripublic:

Data(); // DefaultData( int g, int m, int a ); // Con parametri

};Data::Data() {} // Def. defaultData::Data(int g, int m, int a) // Def. Con parametri{

giorno=g; mese=m; anno=a;}Data d1; // Chiama il primo costruttoreData d2(28,6,1967); // Chiama il secondo costruttore


Distruttore

// Il distruttore viene chiamato quando l’oggetto e’ distruttoclass Oggetto{public:

Oggetto(); // Costruttore~Oggetto(); // Distruttore

};Oggetto:: Oggetto() { printf(“Creazione\n”); } // Dichi.Oggetto::~Oggetto() { printf(“Distruzione\n”); } //

Dichi.

if(true){

Oggetto x; // L’oggetto e’ creato} // Fine blocco: l’oggetto e’ distrutto


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.


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 classeOggetto(); // 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


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 oggettoprintf(“%s\n”, Data::nome_classe() ); // Call

diretta


Funzioni Membro Costanti

// I membri che non modificano i dati dell’oggetto 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

}


Autoriferimento

// this e’ il puntatore all’oggetto 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;

}


Utilizzo dell’Autoriferimento

// Spesso e’ utile che un membro ritorni un

// Riferiemtno all’oggetto

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();


Definizioni Interne alla classe

// Scrittura classica

class Data

{

int g;

public:

int & giorno();

};

// Scrittura Compatta

class Data

{

int g;

public:

int & giorno()

{

return g;

}

};


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


Sovraccarico degli Operatori

// Si possono ridefinire gli operatori come funzioni

// operator== e’ il nome della funzioneinline 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


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


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


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;


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 );};

// ImplementazioneData & Data::operator= ( const Data & d ){

g = d.g; m = d.m; a = d.a;return *this;

}Data d1,d2,d3; d1 = d2 = d3;


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


11 – Sovraccarico degli operatori


Introduzione

Gli operatori simbolici operanti sugli oggetti possono essere

ridefiniti. Questo vuol dire che posso chiamare una funzione

con un simbolo di operatore.


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


Esempio: confronto di date

class Data {…

// Operatore costante con parametro costantebool operator< ( const Data & d ) const{

if(a!=d.a) return a<d.a;if(m!=d.m) return d<d.m;return g<d.g;

}};Data d1,d2;…if( d1<d2 )… // Utilizzo dell’operatore <if( d1>d2 ).. // Errore! > non definito (neanche di

default)


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 ‘;’


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 l’oggetto

viene creato.


Operatore di assegnamento

inline Point2 & operator= ( const Point2 & p ){

v[0] = p.v[0]; // Copio xv[1] = p.v[1]; // Copio yreturn *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);


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 dell’operatore somma è l’oggetto in questione (this). L’operatore è const (non modifica l’oggetto). 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 l’oggetto


Funzione di stampa

inline void show() const

{

printf(“[%g,%g]\n”,v[0],v[1]);

}

Metodo per la visualizzazione della classe; l’oggetto è visualizzato nella forma: [v0,v1].


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]


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


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


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]<p.v[1]) : (v[0]<p.v[0]);

}


Oggetti Funtori

// Ridefinendo l’operatore 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


12 – Classi derivate


Derivazione

// E’ possibile derivare una classe da un’altra// 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 classek.v[0] = 3; // Eredita i metodo di Point2


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

}


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 l’oggetto e’

// un Punto_Colorato (non stampa il colore)

pc.stampa(); // Stampa il colore


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


Gerarchie esempio MFC


Metodi virtuali

// Per fare in modo che il metodo non dipenda dal tipo

// ma dall’oggetto nell’uso di puntatori si usa:

class Point2

{

public:

virtual stampa();

};

Punto_Colorato pc;

Point2 * punt = &pc;

punt->stampa();

// Chiama Punto_Colorato perche’ virtual


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 è l’unico caso

che comporta un controllo di tipo durante l’esecuzione

del programma.

D’altro canto il meccanismo è indispensabile,

soprattutto nelle interfacce grafiche.


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 astrattaclass PuntoReale{public:

virtual void stampa();// OK: definisce stampa in concreto}


13 - Template

La vera potenza del C++ !


Introduzione ai Template 1

• Supponiamo di voler realizzare la funzione minimo di due interi:

inline int minimo( int a, int b )

{

if(a<b) return a;

else return b;

}

int x = minimo(7,9);

// Nota: inline perché e semplice



• Adesso voglio il minimo fra due double:

inline double minimo( double a, double b )

{

if(a<b) return a;

else return b;

}

Le due funzioni sono identiche a parte la def.

dei tipi. Se voglio altre funzioni minimo (short,

Stringhe, oggetti le devo scrivere tutte).



• In C++ e’ possibile passare un tipo come parametro ad una funzione (o ad una classe):

template<class T> // T e’ il parametro tipoinline T minimo( T a, T b ){

if(a<b) return a; else return b;}

// Utilizzo:double x = minimo<double>(3.9, 7.5); // T=doubleint k = minimo<int>(4,5); // T=intint s = minimo(2,3); // Inferenza del tipo: T=int


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’ l’unico linguaggio di programmazione

che ha i template.• I template sono la base costruttiva della

Libreria Standard.


Classi Template

// Es. Posso definire la classe Punto senza

// Specificare il tipo delle coordinate

template<class S>

class Point2

{

public: S v[2];

};

Point2<double> p1; // Punto doppia precisione

Point2<float > p2; // Punto singola precisione

Point2<int > p3; // Punto intero


Esempio template!

• Es1: point– Consultate i lucidi relativi alla esercitazione 1: classe point

• Es2: vector– Consultate i lucidi relativi alla esercitazione 2: classe vector


3 Libreria Standard


Introduzione alla STL

• La libreria standard e’ uno dei punti più alti dell’informatica.

• Raccoglie i risultati teorici dell’informatica 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 dell’STL e’ realizzato con la massima efficienza.


Stringhe

• Il C++ non ha il tipo stringa come oggetto base; la libreria standard introduce l’ogggetto 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;


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.


STL - iteratori

• Ad ogni contenitore e’ associato il proprio oggetto iteratore.

• L’iteratore 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).


Vector

// vector introduce i vettori dinamici non presenti nel

// C++ base.

// Vector ha un parametro template sul tipo Contenuto:

vector<int> v; v.resize(1000); v[999] = 3;

vector<Data> d; // Vettore di date

// d.front() : primo elemento |d.begin() : it inizio

// d.back() : ultimo elemento|d.end() : it fine

// Scansione:

vector<Data>::iterator i; // iteratore associato

for(i=d.begin();i!=d.end();++i)

i->stampa(); // si usa come un puntatore


List

List implementa le liste di oggetti. List non ha l’operatore [] (non e’ possibile indirizzare l’ennesiomo elemento), ma l’inserimento e l’estrazione di un elemento sono molto veloci.

list<double> l; // Lista di valori

l.push_front(9); // Inserimento in testa

l.push_back(11); // Inserimento in coda

list<Data>::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


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<Data,string> eventi; // Da date a stringhe

eventi[ Data(28,6,1967) ] = “Compleanno”;

string s = eventi[Data(28,6,1967)];


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.


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 l’uguaglianza

10. search Cerca sottosequenza

11. search_n Cerca n elementi uguali

12. find_end Cerca a partire dalla fine


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 l’ordine• rotate Ruota l’ordine• random_shuffle Mescolamento Casuale (*SGI

ext.*)


Ordinamenti

• sort ordinamento! Spesso si usano oggetti funtori per comparare gli oggetti

• lower_bound ricerca binaria O(log(n))• upper_bound

Ci sono molte altre cose (funtori), ma per ora non le vedremo.


Interfacce grafiche

• Es3: mfc– Consultate i lucidi relativi alla esercitazione 3: applicazione grafica con Microsoft Foundation Classes


Esercitazioni ed Esempi

• Manipolazione di testi• Database (odbc o MySql)• Libtiff• Cenni ad OpenGL


Argomenti avanzati del C++

• Parametri non specificati• Eccezioni• Puntatori a funzioni• Cast specificati• Mutable• Problemi dell’ereditarieta’ multipla

C/C++

Documents

Transcript of C/C++