Lab. Calc. AA 2005/061 Classi. Lab. Calc. AA 2005/062 C e C++ Fino a questo punto abbiamo introdotto gli elementi base di qualsiasi linguaggio di programmazione,

Slides:



Advertisements
Presentazioni simili
Programmazione ad oggetti
Advertisements

Puntatori Linguaggio C.
© 2007 SEI-Società Editrice Internazionale, Apogeo Unità F1 Primi programmi.
Introduzione al linguaggio C++
Corso di Fondamenti di Programmazione canale E-O
Puntatori e gestione dinamica della RAM
LINGUAGGIO DI PROGRAMMAZIONE C
Nel C non esiste un dato primario di tipo stringa; queste sono rappresentate con un array monodimensionale di caratteri (tipo char). Così per definire.
Funzioni Friend Come abbiamo visto non possiamo accedere a membri privati di una classe dall'esterno della classe. Ma a volte abbiamo bisogno di farlo.
Oggetti Java.
Strutture dati In linguaggio C. Strutture Spesso gli algoritmi lavorano su insiemi di dati eterogenei Per esempio, per descrivere le caratteristiche di.
Classi ed Oggetti in Java (Cenni). Richiami Ruolo delle Classi in Java Oggetti.
Introduzione al linguaggio C
Introduzione al linguaggio C Dr. Francesco Fabozzi Corso di Informatica.
Fondamenti di Informatica
La ricorsione Simulazione. Il Main /* Programma che usa una funzione ricorsiva*/ #include #define MAX_N 8 main() int valore, dato; printf(Introduci n:
Programmazione Procedurale in Linguaggio C++
Caratteri e stringhe di caratteri
Funzioni definite dall’utente
Tail recursion: esempio
Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di programmazione a.a. 2009/2010 Prof.ssa Chiara Petrioli.
Calcolatori Elettronici III
Laboratorio di Linguaggi lezione VI: puntatori 2/3 Marco Tarini Università dellInsubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese Corso.
Laboratorio di Linguaggi P R I M O C O M P I T I N O Marco Tarini Università dellInsubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese.
Introduzione al linguaggio C++ 5 lezioni
1 Corso di Laurea in Biotecnologie Informatica (Programmazione) Introduzione a JAVA Anno Accademico 2009/2010.
1 Corso di Laurea in Biotecnologie Informatica (Programmazione) Array Anno Accademico 2009/2010.
1 Lezione XIII Lu 17-Nov-2005 Programmare le classi.
APPUNTI SUL LINGUAGGIO C
LdL - LP1 - ver. 6 - lez aa Linguaggi di programmazione I La ricorsione Prof. Luigi Di Lascio Lezione 10.
Fondamenti di Informatica I a.a Il linguaggio C Il controllo di flusso La selezione condizionale Listruzione switch I cicli Le istruzioni break,
Procedure e funzioni nei linguaggi di alto livello Lab Programmazione - turno /2006.
Oggetti e dati primitivi
Approfondimento delle classi
CAPITOLO 4 LINGUAGGIO JAVA: COSTRUTTI DI BASE. ALFABETO Java adotta la codifica standard Unicode della società Unicode, Inc. (ftp://ftp.unicode.org) definito.
Funzioni. Lab.Calc. AA 2005/062 Astrazione Consiste nell'ignorare i dettagli e concentrarsi sull'essenziale: in particolare ci consente di utilizzare.
Iterazioni (for, do, while). Lab.Calc. AA2005/062 Iterazioni 3 istruzioni che consentono di eseguire un loop (ciclo): 1. while 2. do...while 3. for con.
Creazione di un programma eseguibile. Laboratorio di Calcolo AA2005/062 Livelli di programmazione Si può programmare a diversi livelli utilizzando linguaggi.
Lab. Calc. 2005/06 Ereditarietà. Lab. Calc. 2005/06 Scopo di questa lezione: Imparare a creare nuove classi ereditando da classi già esistenti. Capire.
Istruzioni di selezione (If/else/switch)
Vettori e matrici. Lab.Calc. AA2005/062 Vettori Dichiarazione di un vettore di oggetti del tipo Tipo: Tipo identificatore[dimensione]; Uso di un elemento.
Primi Elementi di Programmazione in C++
Lab. Calc. AA 2005/061 puntatori. Lab. Calc. AA 2005/062 Attributi di un oggetto nome o identificatore; tipo o classe; valore o valori; indirizzo;
1 laboratorio di calcolo II AA 2003/04 quarta settimana a cura di Domizia Orestano Dipartimento di Fisica Stanza tel. ( )
Le classi Definizione di classe Attributi e metodi di una classe Costruttori e distruttori Private e public Funzioni friend Il puntatore this.
Struct, enum, Puntatori e Array dinamici
Esercizi FUNZIONI Passaggio di parametri per valore, variabili e tipi locali e globali, prototipo.
Esercizi Puntatori, struct con campi puntatore, puntatori a struct, rapporto tra array e puntatori. FUNZIONI Passaggio di parametri per indirizzo, passaggio.
Fondamenti di Informatica A - Massimo Bertozzi TIPI DI DATO IN C++ What's in a name? That which we call a rose By any other name would smell as sweet.
Il Linguaggio C.
Le funzioni.
Equazione di secondo grado.
Il linguaggio C Le funzioni C Language Il passaggio dei parametri
Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di programmazione a.a. 2009/2010 Prof.ssa Chiara Petrioli.
Unità Didattica 3 Linguaggio C
Enumerazioni e Classi 1. Enumerazioni Permettono di definire nuovi tipi che consistono in un insieme di valori costanti (ognuno con un nome) – Migliorano.
I metodi F. Bombi Campi e metodi Abbiamo visto che una classe può contenere – Campi – Metodi stato I campi sono utilizzati per memorizzare.
Fondamenti di Informatica 2 Ingegneria Informatica Docente: Giovanni Macchia a.a
Prof.ssa Chiara Petrioli -- corso di programmazione 1, a.a. 2006/2007 Corso di Programmazione 1 a.a.2006/2007 Prof.ssa Chiara Petrioli Corso di Laurea.
1 Fabio Scotti ( ) Laboratorio di programmazione per la sicurezza Valentina Ciriani ( ) Laboratorio di programmazione Lezione 11 e 12 -
Definizione di classi Capitolo 18 febbraio 2004 Definizione di classi.
Prof.ssa Chiara Petrioli -- corso di programmazione 1, a.a. 2006/2007 Corso di Programmazione 1 a.a.2006/2007 Prof.ssa Chiara Petrioli Corso di Laurea.
Ugo de'Liguoro - Informatica 2 a.a. 03/04 Lez. 7 Tipi di dato e strutture dati Specifica e realizzazione di strutture informative come classi.
Fondamenti di Informatica 2 Ingegneria Informatica Docente: Giovanni Macchia a.a
1 Il linguaggio C Precisazioni sull’esperienza in laboratorio.
Progettare una classe 21 Febbraio La classe BankAccount Vogliamo realizzare una classe i cui oggetti sono dei semplici conti bancari. * Identifichiamo.
Copyright © Istituto Italiano Edizioni Atlas
Informatica B Allievi Elettrici - AA Fondamenti della programmazione in linguaggio C (III)
Introduzione all’Ereditarietà Pietro Palladino. Richiami UML Classe: descrizione di un insieme di oggetti software con caratteristiche simili Definisce.
Introduzione alle Classi e agli Oggetti in Java 1.
Transcript della presentazione:

Lab. Calc. AA 2005/061 Classi

Lab. Calc. AA 2005/062 C e C++ Fino a questo punto abbiamo introdotto gli elementi base di qualsiasi linguaggio di programmazione, ed in particolare quelli comuni al C e al C++. Tutto ciò che abbiamo visto è valido anche per il C con pochi semplici accorgimenti –Sostituzione di iostream.h con stdio.h (e degli oggetti cin e cout con le funzioni scanf e printf) –Sostituzione di new e delete con malloc o calloc e free

Lab. Calc. AA 2005/063 Oggetti Abbiamo introdotto diversi oggetti: oggetti numerici (int n, double x, char lettera...), vettori di oggetti numerici tutti dello stesso tipo (double dati[10], string nome o char nome[20]...), ma anche oggetti di un nuovo tipo: cin (tipo istream) e cout (tipo ostream)...

Lab. Calc. AA 2005/064 Tipi Oltre ai tipi predefiniti (int, float, double, char, long, short, unsigned int...) che corrispondono a singoli oggetti numerici sia il C che il C++ consentono di definire dei nuovi tipi associati a degli insiemi di oggetti, anche di tipo non omogeneo. Esempio: documento di identità, definiamo il tipo CI int numero_documento; string nome; string cognome; string luogo_nascita; float altezza; int data_nascita; // nel formato ggmmaa

Lab. Calc. AA 2005/065 Nuovi tipi In C si possono definire degli oggetti composti associati a dei nuovi tipi mediante dei costrutti chiamati strutture (struct) o unioni (union). In C++ si possono ancora usare le strutture del C ma si dispone di cotrutti molto più potenti: le classi.

Lab. Calc. AA 2005/066 Classe Una classe è un nuovo tipo di oggetto (come int, float, double...) con la possibilità: –Di far corrispondere all'oggetto un insieme di valori numerici anche di tipo non omogeneo –Di decidere se (e come) tali valori possano essere acceduti dall'esterno –Di definire delle funzioni responsabili della manipolazione di questi dati (metodi)

Lab. Calc. AA 2005/067 Oggetti di una classe Dati creazione inizializzazione accesso ai dati stampa... manipolazione dei dati

Lab. Calc. AA 2005/068 Uso di una classe predefinita Come nel caso delle funzioni di libreria esistono delle classi predefinite che il programmatore può utilizzare (istream e ostream per esempio). Per usarle è sufficiente conoscere la loro interfaccia (e includerla nel proprio codice), ovvero di che tipo di oggetti si tratta e quali siano i metodi attraverso i quali gli oggetti possono essere acceduti dall'esterno (creati, inizializzati, cancellati, stampati, usati...). Questi metodi sono metodi pubblici, chiamabili da tutti, altri, dichiarati privati, possono essere chiamati solo da altri metodi della classe stessa.

Lab. Calc. AA 2005/069 Sintassi class identificatore { accesso1: membro accessoN: membro N1… membro N2 };

Lab. Calc. AA 2005/0610 identificatore è un qualsiasi identificatore (nome) consentito da accesso1 fino a accessoN possono essere: public, private o protected. Ogni membro è o un dato o una funzione (metodo). Un membro dato è una dichiarazione di un oggetto. Una membro funzione è la dichiarazione di una funzione o la sua implementazione.

Lab. Calc. AA 2005/0611 Esempio Costruiamo un nuovo tipo, Punto2D, che descriva un punto nel piano. Le sue proprietà sono: –Dati privati: 2 coordinate –Metodi: Creazione di un oggetto punto date le 2 coordinate, Accesso in lettura alle 2 coordinate, Calcolo della distanza tra due punti Stampa dei parametri

Lab. Calc. AA 2005/0612 Punto2D.h (dichiarazione) #ifndef Punto2D_H #define Punto2D_H class Punto2D { private: double coordX;// coordinata X double coordY;// coordinata Y public: Punto2D( );// crea senza inizializzare Punto2D(double X, double Y); // crea da(X,Y) double distanza(Punto2D punto); // distanza double x( );// restituisce X double y( );// restituisce Y void stampa( );// stampa (X,Y) }; #endif

Lab. Calc. AA 2005/0613 Punto2D.cc (implementazione) #include "Punto2D.h" #include #include Punto2D::Punto2D( ) { } Punto2D::Punto2D(double X, double Y) { coordX=X; coordY=Y; }

Lab. Calc. AA 2005/0614 double Punto2D::distanza(Punto2D punto) { double deltaX = coordX - punto.x( ); double deltaY = coordY - punto.y( ); return sqrt( deltaX*deltaX + deltaY*deltaY ); } double Punto2D::x( ) {return coordX; } double Punto2D::y( ) {return coordY;} void Punto2D::stampa( ) { cout << "(" << coordX << "," << coordY << ")" << endl; }

Lab. Calc. AA 2005/0615 Uso di Punto2D #include #include "Punto2D.h" int main( ) { Punto2D origine(0,0); origine.stampa( ); // oggetto.metodo( ) double x,y; cin >> x >> y; Punto2D punto(x,y); punto.stampa( ); Punto2D * puntatore; puntatore = &punto; puntatore->stampa( ); // puntatore->metodo( ) return 1; }

Lab. Calc. AA 2005/0616 Esempio Costruiamo un nuovo tipo, Retta2D, che descriva una retta nel piano. Le sue proprietà sono: –Dati privati: 3 parametri –Metodi: Creazione dati 2 punti Creazione dati 1 punto e una direzione Calcolo dell'intersezione con un'altra retta Calcolo della distanza da un punto Accesso ai 3 parametri e stampa dei parametri (se ne potrebbero pensare tanti altri: creazione dati i 3 parametri, ricerca di una retta ortogonale etc...)

Lab. Calc. AA 2005/0617 Retta2D.h (dichiarazione) #ifndef Retta2D_H #define Retta2D_H #include "Punto2D.h" class Retta2D { private: // Ax + By + C = 0 double A; double B; double C; public: double a( );// restituisce A double b( );// restituisce B double c( );// restituisce C void stampa( );// stampa A,B,C

Lab. Calc. AA 2005/0618 public: Retta2D(Punto2D p1, Punto2D p2); // crea la retta passante per p1 e p2 Retta2D(Punto2D p, double xDir, double yDir); // crea la retta per p parallela al vettore //(xDir,yDir) Punto2D intercetta(Retta2D altra_retta); // punto di intersezion con altra_retta double distanza(Punto2D punto); // distanza da un punto static double toll_parallelismo; // angolo minimo (rad) tra rette non parallele }; #endif

Lab. Calc. AA 2005/0619 Retta2D.cc: implementazione #include "Retta2D.h" #include #include double Retta2D::toll_parallelismo = 0.01; // questo è un dato pubblico della classe, condiviso da // tutti gli oggetti Retta2D. Averlo definito con la // parola chiave static permette di riservargli la memoria // una sola volta anzichè farlo per ogni oggetto // Retta2D creato

Lab. Calc. AA 2005/0620 Retta2D::Retta2D(Punto2D p1, Punto2D p2) { if( p1.x() == p2.x() ) { // retta verticale A = 1; B = 0; C = -p1.x(); } else { A = p2.y() - p1.y(); B = p1.x() - p2.x(); C = p1.y()*p2.x() - p2.y()*p1.x(); } } Retta2D::Retta2D(Punto2D p, double xDir, double yDir) { A = yDir; B = -xDir; C = - A*p.x() - B*p.y(); }

Lab. Calc. AA 2005/0621 Punto2D Retta2D::intercetta(Retta2D altra_retta) { double det = A * altra_retta.b( ) - altra_retta.a( ) * B; double sin2 = ( det*det ) / ( (A*A + B*B)* (altra_retta.a( )*altra_retta.a( )+ altra_retta.b( )*altra_retta.b( )) ); if( sin2 < toll_parallelismo*toll_parallelismo) { return Punto2D(FLT_MAX,FLT_MAX); } else { double X = (B*altra_retta.c( ) - altra_retta.b( )*C)/det; double Y = (C*altra_retta.a( ) – altra_retta.c( )*A)/det; return Punto2D(X,Y); } }

Lab. Calc. AA 2005/0622 double Retta2D::distanza(Punto2D punto) { return fabs( A*punto.x( ) + B*punto.y( ) + C)/sqrt(A*A+B*B); } double Retta2D::a( ) { return A; } double Retta2D::b( ) { return B; } double Retta2D::c( ) { return C; } void Retta2D::stampa( ) { cout << A << " x + " << B << " y + " << C << " =0" << endl; }

Lab. Calc. AA 2005/0623 Modifiche in Punto2D.h Aggiungiamo un metodo per calcolare la distanza tra il Punto2D ed una retta di tipo Retta2D tra i metodi public double distanza(Retta2D retta); Per far conoscere la classe Retta2D a Punto2D dovremmo includere Retta2D.h, ma Retta2D.h include a sua volta Punto2D.h. Per evitare problemi ci limitiamo quindi a dire in Punto2D.h, prima della dichiarazione di class Punto2D, che esiste una classe Retta2D, mediante la dichiarazione class Retta2D;

Lab. Calc. AA 2005/0624 Modifiche in Punto2D.cc Aggiungiamo l'implementazione del metodo distanza, che utilizza il metodo della classe Retta2D double Punto2D::distanza(Retta2D retta) { return retta.distanza(*this); // this è il puntatore all'oggetto // stesso e *this è // l'oggetto stesso (Punto2D) } Adesso non basta pi ù sapere che esiste una classe Retta2D: usiamo un suo metodo, ci serve la sua dichiarazione! Punto2D.cc deve quindi includere Retta2D.h #include "Retta2D.h"

Lab. Calc. AA 2005/0625 Uso di Retta2D e Punto2D #include #include "Punto2D.h" #include "Retta2D.h" int main( ) { Punto2D origine(0,0); Punto2D P(1,1); Retta2D R(origine,P); R.stampa( ); return 1; }

Lab. Calc. AA 2005/0626 Altri esempi timeObject Date

Lab. Calc. AA 2005/0627 Esempio timeObject: dichiarazione (timeObject.h) class timeObject{ private: int hours; int minutes; int seconds; public: void setTime(int, int, int); //impostazione void increment(int,int,int); //variazione void display( );// stampa int after(timeObject); // confronto int operator==(timeObject); //confronto };// attenzione, il ; finale serve!

Lab. Calc. AA 2005/0628 timeObject:implementazione (timeObject.cc) void timeObject::setTime(int h,int m,int s){ hours = h; minutes = m; seconds = s; } void timeObject::increment(int h,int m,int s){ hours = hours + h; minutes = minutes + m; seconds = seconds + s; } void timeObject::display( ){ cout << hours <<" hours: " << minutes << " minutes: " << seconds << " seconds: " << endl; }

Lab. Calc. AA 2005/0629 int timeObject::after(timeObject t){ if (hours > t.hours)return 1; if(hours < t.hours) return 0; if (minutes > t.minutes)return 1; if(minutes < t.minutes) return 0; if (seconds > t.seconds)return 1; if(seconds < t.seconds) return 0; return 0; } int timeObject::operator==(timeObject t){ return (hours == t.hours && minutes == t.minutes && seconds == t.seconds); }

Lab. Calc. AA 2005/0630 #include #include "timeObject.h" int main( ){ timeObject t;// dichiarazione t.setTime(10,4,21);//inizializzazione t.display( );// stampa t.increment(1,5,31)// variazione t.display( );// stampa timeObject newTime;// dichiarazione newTime.setTime(11,15,45);//inizializzazione cout<<(t == newTime)<<endl; // confronto return 1;} Esempio: programma che utilizzi timeObject

Lab. Calc. AA 2005/0631 Esempio Date: dichiarazione (Date.h) class Date { private: int day; int month; int year; public: Date(int=1,int=1,int=0);// costruttore void setDay(int d){ day = d;}// impostazione day void setMonth(int m){month =m;}// imp. month void setYear(int y){year =y;}// imp. year int getDay( ){return day;} // lettura day int getMonth( ){return month;} // lettura month int getYear( ){return year;} // lettura year void usDisplay( ); void interDisplay( ); };

Lab. Calc. AA 2005/0632 Date: implementazione (Date.cc) Date::Date(int d, int m, int y){ day = d; month = m; year = y; } void Date::usDisplay( ){ cout<<month<<"/"; cout<<day<<"/"<<year; } void Date::interDisplay( ){ cout<<day<<"/"; cout<<month<<"/"<<year; }

Lab. Calc. AA 2005/0633 Metodi indispensabili Per ogni classe sono indispensabili i seguenti metodi: –Costruttori –Distruttore Il compilatore definisce automaticamente il costruttore di un oggetto non inizializzato e quindi se non volete aggiungere qualcosa in questo metodo (ad esempio una stampa che dica che viene creato un nuovo oggetto) non serve dichiararlo ed implementarlo. Analogamente il compilatore definisce automaticamente il costruttore di copia.

Lab. Calc. AA 2005/0634 Costruttore di copia Sintassi: idClasse(const idClasse & ); Il costruttore di copia viene invocato in tre situazioni: 1 dichiarazioni con assegnazione: Punto2D p(0,0); Punto2D pbis=p; 2 quando si passi un oggetto come parametro in una chiamata a una funzione: retta.distanza(punto); 3 quando un oggetto viene ritornato da una funzione punto=retta.intersezione(altra_retta);

Lab. Calc. AA 2005/0635 Distruttore sintassi: ~idClasse( ); Il distruttore libera la memoria occupata dall'oggetto. Il distruttore viene chiamato dal compilatore quando si esce dallo scope in cui è stato definito l'oggetto: { Punto2D p(0,0); } // viene chiamato ~Punto2D( )

Lab. Calc. AA 2005/0636 Se tra i dati membri di una classe c'è un puntatore Il compilatore automaticamente vi copierà nel puntatore l'indirizzo presente nel puntatore dell'oggetto originale… Che succede quando il primo oggetto viene cancellato? In questo caso 1. Dovete definire e implementare un costruttore di copia 2. Dovete fornire e implementare un distruttore 3. Dovete ridefinire l'operatore di assegnazione operator= 4. Dovete ridefinire l'operatore di uguaglianza operator==