C. Genta Tecniche di Programmazione e Analisi Dati a.a...

C++

C. GentaTecniche di Programmazione e

Analisi Datia.a. 2007/08

C. Genta – Tecniche di programmazione e analisi dati 2

Perche’ il C++?

E’ necessario utilizzare dei calcolatori per analizzare i dati raccolti agli esperimenti di fisica delle particelleEsistono dei programmi sviluppati da altri che ci aiutano in questoIl piu’ importante in fisica delle particelle e’ ROOT– http://root.cern.ch

ROOT e’ la versione in C++ di un preceden programma che si chiamava PAW ed era scritto in Fortran


Cosa faremo?

Cerchero’ di darvi il minimo di basi necessarie perche’ possiate usare ROOTSeguiro’ un corso gia’ fatto negli anni scorsi a Firenze da R. Ranieri e L. Bellucci, con alcuni aggiornamenti...Oltre alle slide del corso in rete potete trovare anche un ottimo libro se volete approfondire:

“Thinking C++” di B. Eckel: http://hep.fi.infn.it/TIC2Vone.pdf http://hep.fi.infn.it/TIC2Vtwo.pdf


Primi elementi di C++

La funzione main è una funzione speciale, la prima da cui parte l’esecuzione del codiceOgni linea di comando deve finire con ;– Gli spazi non contano e si puo’ andare a capo in una

linea di comando

// indica una linea di commentoTutta la regione inclusa tra /* e */ e’ commentata

int main() {

// questo e’ un commento

return 0;

}


Variabili e funzioni predefinite

Esistono dei “tipi” di variabile predefiniti– Un numero intero (int)– Un numero reale (float)– Un carattere (char)– Una variabile logica vera o falsa (bool)– Una variabile “senza tipo” (void)

Il C/C++ è dichiarativo: ogni variabile che deve essere utilizzata deve essere dichiarata prima (cioè dobbiamo specificare se è intera o cosa altro)– Attenzione! minuscolo è diverso da maiuscolo

Non esistono funzioni predefinite o intrinseche– Si possono tuttavia “caricare” delle funzioni definite tramite gli

“header” file


Scrivere qualcosa in output

int a=7;std::cout << “Hello world! a=” << a <<std::endl;

Esiste anche std::cerr per mandare l'ouput nello stderr.

std::cout = output,di solito lo schermo

operatore << immaginatelo come una freccia:

Hello world! va a finire sull’output

Stampa il valore di a

Sullo schermo: Hello world! a = 7

std::endl dice di andare a capo


Input

Per leggere un input da tastiera– int a;– std::cin >> a;

Anche l'operatore >> puo' essere concatenato per leggere piu' variabili di input separate da caratteri di spazio, Tab, o a capo :

std::cin>>x>>y;

std::cin = input,la tastiera

Metti (freccia) quello che hai letto da tastiera nella variabile a


Esempio: InputOutput.cpp

#include <iostream>

int main() {

bool b=true;

char c='a';

int i=1;

float f;

std::cin >> f;

std::cout << b << " " << c << " " <<

i << " " << f << endl;

return 0;

}

Carica le funzioni di I/O


Compilare ed eseguire un programma

Il comando per compilare è– g++

esempio:> g++ InputOutput.cpp> ./a.out

oppure> g++ -o InputOutput InputOutput.cpp> ./InputOutput


Namespace

Perche’ devo scrivere sempre std:: davanti a cin e cout ?In C++ i vari oggetti sono suddivisi in compartimenti (namespace)– Posso avere una variabile a definita in un

compartimento, e questa sarà diversa dalla variabile a definita in un’altro

– int pippo::a;– int pluto::a;


In C++

cin e cout sono definite nel namespace std, per cui devono essere chiamati come std::cin e std::cout;Oppure: posso dire una volta per tutte al compilatore che anche se non specifico nulla, assuma che io voglio lavorare in un namespace definitousing namespace std;

Sembra una complicazione inutile ma se per caso decidete di fare un vostro cout e cin privato potete definirli in un altro namespace e passare da uno all'altro semplicemente comabiando:using namespace mionamespace;


Funzioni

Abbiamo gia’ visto la funzione main()Quando si definisce una funzione devo dichiarare il tipo di oggetto che restituiscePuo’ essere float, int, ecc... ma anche nulla, cioe’ void Tra parentesi tonda si indicano gli argomenti– con il loro tipo

Tra parentesi graffe si implementa la funzioneIl risultato viene restituito con – return qualcosa;


Esempio: swap.cpp

Immaginiamo una funzione che deve scambiare due interi

Facile, no?

void swap(int i1, int i2) { // Swap arguments int temp = i1; i1 = i2; i2 = temp;}


Argomenti per valore

Peccato che non funzioni...La funzione scambia effettivamente il valore di i1 e i2, ma non quello delle variabili che sono state passate come argomento, cioe’ c e d nell’esempio qui sotto

In altre parole in questo modo si passa il valore della variabile come argomento e non la variabile

int c=3;int d=4;swap(c, d);


PuntatoriCome in C anche in C++ esistono i puntatori:

int* a;significa che a contiene l’indirizzo di memoria di inizio una variabile intera– una variabile intera e’ costituita da 4 bytes

Un puntatore si puo’ assegnare usando l’operatore &

int b=8;int *i;i = &b;

nota : un puntatore puo’ essere 0 nel qual caso si dice che e’ un puntatore “nullo”. Se si cerca di accedere al valore di un puntatore nullo si ha un crash. Esempio:

int *p=0;int b=*p; // questa riga fa crashare il programma


Puntatori

Anteponendo una * al puntatore si ottiene la variabile alla quale “punta”– puo’ essere utilizzato anche per assegnare un valore– se il puntatore e’ nullo l’operazione di dereferenziazione puo’

generare un errore

Quanto valgono a,b,*i? E &a, &b, i quanto valgono?Provate a scriverli con cout...E adesso provate a modificare la funzione swap()

int b=8;int *i = &b;int a = *i; *i = 9;


Nulla di nuovo rispetto a C?

In realta’ in C++ esiste una alternativa al passare il puntatore ad una variabile: usare una reference. La reference e' un alias della variabile. Cambiare il valore della reference equivale a cambiare la varibile di cui e' l'alias

Quanto valgono a,b,c? E &a, &b, &c quanto valgono?Vi viene in mente un altro modo di modificare swap()?

int b=8;

int& c=b;

int a = c;

c = 9;


Reference vs puntatore

Una reference deve essere sempre inizializzata.A differenza dei puntatori, una volta che una reference a una variabile e' creata non puo' essere cambiata per diventare reference di un'altra variabile.In linea di principio e' piu' sicura di un puntatore perche' non puo' mai essere nulla dovendo essere sempre associata a un oggetto.


Reference

Posso utilizzare delle reference negli argomenti di swap()

Perche’ funziona? Qual’e’ il vantaggio?

void swap(int& i1, int& i2) { // Swap arguments int temp = i1; i1 = i2; i2 = temp;}


Vettori

Un vettore di 5 reali si definisce nel seguente modo:float x[5];

Che significa esattamente? Se facciamo un dump della memoria troviamo:

*x e x[0] sono la stessa cosax e &x[0] sono la stessa cosaNota: ma x indica un vettore e non un puntatore!


ArrayAndPointer.cpp

Consideriamo:

y e z sono puntatori a x[0]y+1 e’ un puntatore a x[1] y[1] e’ una abbreviazione per *(y+1)Le operazioni di addizione e sottrazione di interi sono permesse sui puntatori

float x[5]={0., 1.1, 2.2, 3.3, 4.4};float *y = &x[0];float *z = x;

cout << "*y = " << *y << “, *z = " << *z << endl;cout << "*(y+1) = " << *(y+1) << “, y[1] = " << y[1] << endl;


Allocazione dinamica della memoria

E’ possibile definire la dimensione di un vettore durante l’esecuzione

E’ anche possibile creare un oggetto in memoria in modo tale che non sia cancellato quando la funzione termina (usa la memoria heap anziche’ lo stack della funzione)

int n;cin >> n; float x[n];

int n;cin >> n; float* x = new float[n] ;


deleteL’unico problema e’ che bisogna ricordarsi di cancellarlo quando non ne abbiamo piu’ bisogno

Funziona anche per variabili semplici, non soltanto vettori

NOTA: Un volta cancellato, bisogna ricordarsi di non usare piu' il puntatore altrimenti il programma crasha.

float* x = new float[5];

...

delete [ ] x;

float* x = new float;

...

delete x;

float* x = new float;

delete x;

std::cout<<”Puntatore a x= ”<<x<<std::endl;

std::cout<<”Valore di x= “<<*x<<std::endl;

Stampa il puntatore di x (diverso da 0!)

Tenta di accedere a x che e' stato cancellato → crasha


if e if ... else

if ( a == b ) c = 2;

if ( a == b ) { c=2;}

if ( a == b ) { c=2;}else{ c=1;}


operatori

Per vostra referenza


Cicli condizionali

int i;for (i=0; i<10; i++) { cout<<i<<endl;}

int i=0;while (i<10) { cout<<i<<endl;

i++;}

Esercizio: creare una funzione che restituisce la somma degli elementi di un vettore


Programmazione a oggetti

Fin qui la parte noiosa...Sostanzialmente abbiamo descritto la sintassi del C++, ma senza introdurre nessun elemento di programmazione a oggettiChe significa programmare a oggetti?


Come si affronta un problema complesso ?

Generalmente la soluzione di un problema complesso con metodi IT avviene in 3 fasi:

• ASTRAZIONEASTRAZIONE

• DECOMPOSIZIONEDECOMPOSIZIONE

• ORGANIZZAZIONEORGANIZZAZIONE

I diversi paradigmiparadigmi disponibili nella programmazione (procedurale, object-oriented) affrontano le 3 fasi in maniera molto diversa


Procedurale

Il paradigma proceduraleprocedurale affronta un problema in termini di funzioni che agiscono su dei dati:

1.1. ASTRAZIONEASTRAZIONE– formalizzazione del problema in termini di un processoprocesso che

lo risolve

2.2. DECOMPOSIZIONEDECOMPOSIZIONE– dividere la procedura di soluzione in unità più piccole,

facilmente maneggiabili (funzionifunzioni)

3.3. ORGANIZZAZIONEORGANIZZAZIONE– preparare le funzioni in maniera che si chiamino tra loro


Procedurale

PRIMAPRIMA– definire l’insieme di strutture dati

QUINDIQUINDI– definire le funzionifunzioni che agiscono sulle

strutture dati


Object-Oriented

Il paradigma object-orientedobject-oriented affronta un problema in termini di oggetti che interagiscono:

1.1. ASTRAZIONEASTRAZIONE– formalizzazione del problema in termini di agenti

indipendenti (oggettioggetti) che lavorano tra loro

2.2. DECOMPOSIZIONEDECOMPOSIZIONE– definire i tipi degli oggetti su cui suddividere il compito

complessivo

3.3. ORGANIZZAZIONEORGANIZZAZIONE– creare il numero appropriato di oggetti di ogni tipo


Object-Oriented

PRIMAPRIMA– definire il comportamento e le proprietà

dei vari tipi di oggettioggetti definiti

QUINDIQUINDI– creare gli oggetti e metterli al lavoro tra

loro


Procedurale vs Object-OrientedL’utilizzo di linguaggi procedurali comporta vari problemi:

•Evoluzione incontrollata del codice

•Dipendenza del codice dalle strutture datiI linguaggi Object-Oriented Object-Oriented nascono con l’intento di

superare queste limitazioni e rendere più semplice la manutenzione del software. In particolare:

•Riduzione della dipendenza del codice di alto livello da quello di basso livello

•Riutilizzo del codice di alto livello

•Dettagli delle implementazioni nascosti

•Supporto di tipi di dati astratti


Lo stato di un oggetto

Lo stato di un oggetto comprende tutte le sue proprietàOgni proprietà può essere un valore o una reference ad un altro oggetto

Tutti gli oggetti dello stesso tipo hanno le stesse proprietà (con differenti valori…)

Le proprietà sono implementate come variabili nell’oggetto


Il comportamento di un oggetto

Il comportamento di un oggetto definisce come l’oggetto reagisce a modificazioni del suo stato, o come questo interagisce con altri oggetti

Il comportamento è implementato tramite metodi nell’oggetto


Le classi

Una classe è un insieme di oggetti che condividono le stesse proprietà e gli stessi comportamenti La classe è intuitivamente il tipotipo degli oggetti

Nella classe vengono definiti variabili e metodi

Un oggetto che segue la definizione di una classe si chiama istanzaistanza della classe


Un esempio di classe

Vediamo come si dichiara e definisce una classe in C++C++

Come linea generale:Dichiarazione in un headerheader file (estensione .h.h)Implementazione dei metodi in un file di librerialibreria (estensione .cc.cc)

Proviamo a costruire la classe “punto del piano cartesiano”


Punto.hclass Punto{ public: Punto(double x0, double y0); double GetX(); double GetY();

private: double x; double y;};

Variabili per immagazzinare le coordinate del punto.Private significa che non sono accessibili all'utente.

Per accedere alle varie informazioni della classe si utilizzano i metodi

In questo esempio i due metodi GetX() e GetY() permettono di accedere all'informazione contenuta nella classe.(i due metodi qui sono dichiarati ma non implementati. L'implementazione e' nel .cc)

Costruttore dell'oggetto punto nel piano


Punto.hclass Punto{ public: Punto(double x0, double y0); double GetX(); double GetY();

double GetRho(); double GetPhi();

void SetX(double x0); void SetY(double y0);

private: double x; double y;};

L'utente potrebbe volere il punto in coordinate polari oppure settare nuovi valori per le coordinate...

Per accedere ai vari metodi di una classe si usa la stessa sintassi valida per accedere alle variabili di una struttura in C, ovvero “.” e “->” I metodi vengono usati come se fossero funzioni.Es:

#include “punto.h”int main(){ Punto p(2,2); p.SetX(1); cout<<”Rho= ”<<p.GetRho() <<”Phi= ”<<p.GetPhi()<<endl;}


Punto.cc#include ”punto.h”

Punto::Punto(double x0, double y0){ x=x0; y=y0;}

double Punto::GetX(){ return x;}

void Punto::SetX(double x0){ x=x0;}double Punto::GetRho(){ return sqrt(x*x+y*y);}

scrivendo Punto:: informiamo il compilatore di quale classe stiamo parlando

class Punto{ public: .... private: double rho; double phi;};

Se nella classe decido diimmagazzinare le coordinate polari invece che le cartesiane:

Devo cambiare di conseguenza Punto .ccMa cosa deve cambiare l'utente nel programma main()?


Punto

class Punto{ public: Punto(double x, double y); double GetX(); double GetY();

double GetRho(); double GetPhi();

void SetX(double x0); void SetY(double y0);

private: double rho; double phi;};

#include “punto.h”int main(){ Punto p(2,2); p.SetX(1); cout<<”Rho= ”<<p.GetRho() <<”Phi= ”<<p.GetPhi()<<endl;}

Assolutamente niente!L'interfaccia della classe è rimasta la stessa, sono cambiate solo le variabili interne.L'utente non si accorge di niente.

interfaccia


Esempio#include “punto.h”int main(){ //creazione oggetto Punto punto(1,2); // puntatore a un oggetto Punto *p = & punto; // chiamata di metodi p->SetX(0); // vettore di oggetti: Punto punti[100]; punti[0].SetX(0); punti[0].SetY(0);} i metodi dell’oggeto si chiamano con il punto

con il puntatore si usa ->

•g++ -c Punto.cc

crea il file di libreria Punto.o

•g++ Esempio.cpp Punto.o –o Esempio

crea l’eseguibile Esempio

Che cosa succede se scriviamo Punto p;?


CostruttoriDichiarazione:class Punto{ public: Punto(double x,double y); Punto(); Punto(const Punto &); ~Punto(){} //distruttore};Il costruttore ha lo stesso nome della classe e viene chiamato automaticamente quando un oggetto della classe e' creato.Puo' essere utilizzato per inizializzare l'oggetto.Si possono dichiarare piu' costruttori.

Implementazione:Punto::Punto(double x0, double y0){ x=x0; y=y0;}

Punto::Punto(){ x=0.; y=0.;}Punto::Punto(const Punto&p){ x=p.GetX(); y=p.GetY();}

Costruttoredefault

Se non se ne dichiara nessuno, il compilatore crea un costruttore di default che chiama i costruttori di default delle variabili della classe.Anche il costruttore di copia e il distruttore se non dichiarati vengono creati automaticamente dal compilatore.

Costruttoredi copia


Esempi#include “punto.h”int main(){ //creazione oggetto Punto punto(1,2);

//costruttore di copia Punto copia=punto;

//costruttore di default Punto p0;

// costruttore Punto *p = new Punto(2,3);

// distruttore delete p; }


Esempio: un vettore

Avremo bisogno di vettori 3Dvettori 3D per molti scopi:identificare una posizione in un sistema di riferimento (cartesiano, cilindrico, sferico)memorizzare l’impulso di una particella…

Una struttura di questo tipo può essere utilizzata molte volte in un grande progetto software.


Vettore.h

Questo è l’headerheader file per un vettore 3D in coordinate cartesiane


Vettore.cc

Questa e’ l’implementazione dei metodi


Somma di vettori

Possiamo definire una funzione somma()


Overloading di operatori

Il C++C++ ci mette a disposizione degli strumenti più eleganti e funzionali per ottenere lo stesso scopo: la possibilità di fare l’overloadingoverloading degli operatori


Overloading degli operatori I/O

ostream& operator <<(ostream& os, const Vettore v) { os << "(" << v.x() << "," << v.y() << "," << v.z() << ")"; return os;}

Allo stesso modo si puo’ fare l’overloading dell’operatore <<

Utile per non dover ogni volta scrivere ogni componente...


Un passo in più: gli array

La classe Vettore ci permette di fare molte cose, ma naturalmente non ci accontentiamo: vorremmo una classe che ci permetta di decidere la lunghezza del vettore a run-time, in modo da essere più flessible

In particolare vorremmo le seguenti caratteristiche:

• dimensionamento a run-time

• accesso all’iesimo elemento

• utilizzo automatico della memoria, senza bisogno di scrivere esplicitamente nel codice new o delete


FloatArray.h


FloatArray.cc


Non siamo ancora soddisfatti…

… perché essere obbligati ad usare i float ?Possiamo superare il problema usando una classe templatetemplate(bisogna mettere tutto nel .h questa volta...)

#endif


I template all’opera

La classe ArrayArray è molto flessibile: nessuno ci impedisce di definire array non solo di tipi come float, ma anche di qualunque altra classe (Point per esempio)


Ereditarietà

La nostra classe ArrayArray inizia a essere soddisfacente. Non ci dispiacerebbe, però, avere una classe che, quando

usiamo un array di tipi numerici (es: float), ci fornisca gli opportuni operatori matematici: ArrayWithMathArrayWithMath.

D’altra parte vorremmo anche utilizzare il codice scritto finora, e non dover implementare di nuovo i metodi già presenti in ArrayArray nella classe ArrayWithMathArrayWithMath.

Possiamo sfruttare il meccanismo delle classi derivateclassi derivate.


ArrayWithMath.h

Ricordarsi di mettere protectedprotected al posto di privateprivate in Array.h


ArrayWithMath.h

#endif


Ereditarietà

Quando creiamo un’istanza di una classe derivata, questa comunque eredita i metodi delle classi che la precedono nella gerarchia di derivazione


Classi astratte

Stiamo realizzando un programma per disegnare figure geometriche. Per il momento ci limiteremo ai quadrati.


Classi astratteQuesta e’ la classe che disegna il quadrato


Il programma principale


Classi astratte

Cosa succede se oltre ai quadrati vogliamo disegnare i cerchi?Ci serve una classe Cerchio e dobbiamo aggiungere un metodo a Designer per disegnare i cerchi.

Ma è proprio necessario ?


Classi astratte

Square, Circle ed in genere tutte le figure geometriche che ci possono venire hanno alcuni aspetti in comune:un metodo che ci restituisce la posizione sulloschermo la possibilita’ di spostare la figuraun metodo per disegnarlaQuello che possiamo fare e’ definire una interfaccia astratta da cui derivano tutte le figuregeometriche che vogliamo poter disegnare.


Shape.h

L’interfaccia astratta…


Le forme geometriche


Classi astratte

Designer continuerà ad essere una classe molto semplice e non dovremo avere un metodo per ogni forma:

Questo significa programmare interfacce!E nel programma principale cosa succede ?

shape


Classi astratte

Vediamo come è possibile avere un codice semplice e di facile lettura, ma anche totalmente funzionale, se le interfacce sono state pensate (e programmate…) con cura


E poi...

La prossima volta guardiamo ROOTMa nel frattempo provate a pensare a come si puo’ realizzare una classe per estendere ai numeri complessi il C++

Se ci volete provare avrete bisogno di fare – #include <math.h>

per avere tutte le funzioni matematiche tipo sin(), cos(), ecc...

C. Genta Tecniche di Programmazione e Analisi Dati a.a...

Documents

Transcript of C. Genta Tecniche di Programmazione e Analisi Dati a.a...