Introduzione alla programmazione ad oggetti

Introduzione alla programmazione ad oggetti
E.Mumolo, DEEI

Paradigmi di programmazione
È un punto di vista della programmazione Alcuni paradigmi Programmazione imperativa (lista di istruzioni da eseguire, es. Fortran, C, C++, Java ….) Programmazione non strutturata Programmazione strutturata Programmazione dichiarativa (condizioni logiche, es. Prolog, Lisp …) Programmazione procedurale Programmazione ad oggetti …

Architetture software
Programmazione procedurale Funzione principale Sotto-funzione 1 Sotto-funzione 2 Sotto-funzione 1.1 Sotto-funzione 1.2 Sotto-funzione 2.1 Sotto-funzione 2.2

Programmazione non strutturata
Problema: if(90<A<100)and(25<B<100)or(80<A<89)and(50<B<100)or(70<A<79)and(75<B<100) then “ACCETTA” Usando GOTO: SI A>90 SI SI A>80 B>25 SI SI A>70 B>50 SI B>75 Non accetta accetta

Programmazione strutturata
Codice realizzato mediante combinazione di tre strutture Tutti gli algoritmi possono essere realizzati mediante le tre strutture

Programmazione strutturata
SI A>90 SI SI A>80 B>25 SI SI A>70 B>50 SI B>75 N N A N A N A

Programmazione strutturata - pseudocodice
if(A>90) then if(B>25) Accetta else Nonaccetta fi if(AZ80) if(B>50) if(A>70) if(B>75)

Programmazione procedurale
Modello procedurale Il mondo della programmazione viene visto come un sistema di processi Alcuni temi tipici del modello procedurale: Processi, sequenze di esecuzione Diagrammi di flusso Programmazione top-down Programmazione strutturata Algoritmi=strutture dati + programmazione strutturata Tradizionali linguaggi strutturati: Fortran, Pascal, C … Operazioni effettuate sui dati inviate alle procedure e alle funzioni sistemi software validi ed efficienti per basse complessità MA : ad alte complessità si evidenzia un cedimento del sistema Una modifica di una struttura dati ha grandi effetti sul sistema à campo di visibilità delle strutture dati Riusabilita’ nei linguaggi procedurali

Esempio: conto corrente
Programmazione procedurale: Decomposizione funzionale del problema Divisione del problema in moduli Progetto struttura dati, esempio: Implementazione delle funzioni per operare con i dati, esempio: Deposito(ID,#) Preleva(ID,#) CalcolaInteressi(ID) … Numero correntista Nome correntista Saldo Numero operazioni ID correntista … …

Approccio orientato agli oggetti: OOA
metodologia generale pensare e rappresentare problemi usando concetti del mondo reale oggetti: rappresentano proprietà e comportamenti in una unica entità I modelli possono essere implementati usando un linguaggio di programmazione, un sistema di gestione di archivi, in hardware etc…

Alcune differenze tra OO e procedurale
OOP  dati e comportamento contenuti in un oggetto singolo Procedurale  dati e comportamento separati OOP  divide il problema in oggetti separati che realizzano azioni relazionandosi con altri oggetti Vantaggi proncipali di OOP: Dati e operazioni incapsulati in un oggetto Quando viene creato un nuovo tipo di oggetto, non è necessario modificare le implementazioni precedenti Piuttosto, il nuovo oggetto eredita alcune caratteristiche precedenti Programmi OO sono di più semplice manutenzione

Programmazione procedurale: L’attenzione del programmatore è concentrata sulle funzioni che manipolano i dati! Ma: l’attenzione di un correntista è più concentrata sui dati che sulle funzioni! Inoltre: Chiunque può modificare i dati (se i dati sono visibili) Funzioni e dati entità separate Punto di vista tradizionale: valore=CalcolaInteressi(ID); valore di ritorno funzione argomento

Programmazione ad oggetti: L’attenzione del programmatore è concentrata sui dati non sulle funzioni Dati e funzioni NON sono entità separate programma ad oggetti: insieme di oggetti cooperanti, che sono istanze di un tipo di dati astratto Esempio di tipo di dati astratto per gestire un conto corrente: ContoCorrente Numero correntista Nome correntista Saldo Numero operazioni deposita(valore) preleva(valore) calcolaInteressi() incrementaNumeroOperazioni leggiNumeroOperazioni() dati funzioni

Programmazione ad oggetti: Un particolare Conto Corrente è una ‘istanza’ del tipo do dati astratto Le funzioni sono attivate mediante messaggi. Un particolare ContoCorrente: cosa è visibile dall’esterno? Punto di vista ad oggetti: valore=ID  CalcolaInteressi(); valore di ritorno oggetto messaggio funzione Dati e funzioni pubbliche: Deposita Preleva leggiNumeroOperazioni CalcolaInteressi  interfaccia Oggetto: ContoCorrente  Dati privati: Numero correntista Nome correntista Saldo Dati protetti: numero operazioni

Utilizzo dell’oggetto: Messaggio: ‘deposita(x)’ oggetto ContoCorrente Messaggio: ‘leggiNumeroOperazioni()’

Cenni di UML UML è un linguaggio (Unified Modeling Language)
Fornisce i costrutti per lo sviluppo di sistemi software: Analisi dei requisiti Analisi e progetto OO Modellazione dei componenti Modellazione della struttura e della configurazione Modello espresso mediante diagrammi grafici

Cenni di UML Diagrammi di UML
Diagramma dei casi d’uso: elenca i casi d’uso del sistema e le loro relazioni Diagramma delle classi: struttura dati degli oggetti e loro relazioni Diagramma degli oggetti: mostra un insieme di oggetti e loro relazioni Diarammi di interazione: interazioni tra gli oggetti durante scenari di funzionamento Diagrammi di stato e attività: descrive gli stati di un oggetto e le sequenze eventi-azioni-transizioni Diagramma dei componenti: descrive l’architettura fisica del sistema Diagramma di distribuzione: struttura del sistema hardware e allocazione dei vari moduli software

Cenni di UML Diagrammi dei casi d’uso:
Rappresentano le modalità di utilizzo del sistema da parte degli attori del sistema Descrivono l’interazione tra attori e sistema, la logica interna Un attore Spedisce o riceve messaggi dal sistema, o scambia informazioni con esso Esegue i casi d’uso (funzionalitè percepita da un attore, e sempre attivato da un attore) Corrisponde ad una classe, non ad un oggetto

Cenni di UML Diagramma dei casi d’uso in una biblioteca restituzione
Attore: il bibliotecario prestito Cancella la prenotazione prenota Attore: il cliente

Simboli usati per la visibilità
UML Tool di Reverse eng. ContoCorrente -Numero correntista -Nome correntista -Saldo #Numero operazioni +deposita(valore) +preleva(valore) +calcolaInteressi() -incrementaNumeroOperazioni +leggiNumeroOperazioni() Tipo di dati astratto=classe istanza di un tipo di dati astratto = oggetto incapsulamento = data hiding = fornisce un livello di astrazione attraverso le funzoni  Non c’è struttura dati separata: operazioni e struttura dati integrate in una singola entità

Modelli orientati agli oggetti
Modello ad oggetti Il mondo viene visto come un sistema di cose Comportamento visibile Un oggetto Stato interno nascosto Oggetto = stato + comportamento + identità

Esempio di organizzazione per oggetti
Oggetto automobile Oggetto Carrozzeria Oggetto Motore peso = carrozzeriapeso() + motorepeso() peso = automobile  peso()

Le classi Classificazione:
Oggetti con gli stessi attributi e con gli stessi comportamenti sono raggruppati in classi Classe astrazione che descrive delle proprietà Una classe descrive un insieme di oggetti individuali. Un oggetto è una istanza della classe Ogni istanza ha valori diversi degli attributi Le istanze di una classe condividono i nomi degli attributi e le operazioni

Approccio orientato agli oggetti
Esempio di classi: PezzoScacchi (una Torre è un oggetto della classe) Attributi: Colore, Altezza, Posizione Operazioni: Muove Poligono (un Triangolo è un oggetto della classe) Vertici, ColoreBordi, ColoreInterno Disegna, Cancella, Muove Bicicletta (la mia bicicletta è un oggetto della classe) DiametroRuote, Altezza, Materiale Muove, Ripara, Pulisci

Passi per la modellazione OO
Identificare gli oggetti Identificare il comportamento degli oggetti Identificare le relazioni tra gli oggetti Realizzare gli oggetti: raggruppare in classi le strutture dati ed i comportamenti

Caratteristiche di un oggetto: Attributi (struttura dati) Comportamento Caratteristiche richieste da un approccio orientato agli oggetti: Identità (identity) Polimorfismo (polymorphism) Ereditarietà (inheritance)

Identità: oggetti distinti: ogni oggetto ha la sua identità anche se i loro attributi sono identici Oggetti: entità concrete (es. un file in un file system) o concettuali (es.: una politica di schedulazione) Oggetti del mondo reale (esempio): due mele – anche se dello stesso colore e forma sono due oggetti distinti -, due gemelli, una persona, un oscilloscopio … Oggetti definiti mediante un linguaggio di programmazione (esempio): un albero binario, una tabella …

Polimorfismo: La stessa operazione si comporta diversamente in diverse classi (es. operazione Muovi nella classe PezzoScacchi e Bicicletta). La specifica implementazione di una operazione è chiamata metodo. Polimorfismo=diversi metodi per operatore In un linguaggio orientato agli oggetti il linguaggio seleziona automaticamente il metodo corretto L’utente può non conoscere quanti metodi implementano un operatore

Ereditarietà: Creazione di una gerarchia tra le classi Metodo di progetto bottom-up: una super-classe viene definita in modo generico e poi viene perfezionata via via in sotto-classe La super classe fattorizza le proprietà comuni di diverse classi Una sotto-classe eredita tutte le proprietà della sua superclasse e aggiunge altre proprietà Normalmente le proprietà della superclasse non sono ripetute in ogni sottoclasse

Caratteristiche fondamentali
Astrazione Caratteristiche essenziali di una entità Prima di implementare un oggetto, chiedersi cos’è e cosa fa’ Incapsulamento Chiamato anche ‘Information Hiding’ Separazione degli aspetti esterni (accessibili da oggetti esterni) dalla implementazione interna (nascosti ad oggetti esterni) Rende i programmi robusti dalle piccole variazioni

Caratteristiche fondamentali
Combinazione dei dati e dei comportamenti Approccio convenzionale: procedurale Gerarchia delle strutture dati Gerarchia delle procedure OOA ha una gerarchia unificata Gerarchia delle classi  manutenzione più semplice: il codice non deve essere modificato quando viene aggiunta una classe Importanza del polimorfismo: sposta il problema di decidere l’implementazione da usare alla gerarchia delle classi Esempio: per disegnare in una finestra, basta chiamare un ipotetico metodo draw. Il metodo corretto viene scelto implicitamente

Vantaggi della programmazione ad oggetti
Protezione delle strutture dati Incapsulamento – information hiding Maggiore semplicità di progettazione astratta progettazione top-down e bottom-up, gerarchia di classi composizione delle classi come mattoni fondamentali Migliore riutilizzazione del codice composizione, aggregazione, derivazione Migliore manutenzione del codice le modifiche sono realizzate mediante aggiunta di classi e funzioni virtuali – non è necessario riprendere e modificare l’intero codice Migiore documentazione del codice Strumenti grafici del tipo UML

Diagrammi delle classi e delle istanze Attributi Persona Giulio:Persona Carla : Persona :Persona Persona Giulio:Persona nome=Giulio eta=24 peso=70.1 Carla : Persona nome=Carla eta=25 peso=?? Nome: string Età: integer Peso: float

Nei diagrammi delle classi: Notazione: Persona File Oggetto geometrico Nome Indirizzo Lavoro Nome Dimensione Data_creazione Colore Posizione Cambia_lavoro Cambia_indirizzo move(vettore delta) Select(point p):boolean Ruota(angolo) print Nome della classe Nome attributo:tipo di dato-1=valore default Nome attributo:tipo di dato-2=valore default … Nome operazione-1 (argomenti):tipo risultato Nome operazione-2 (argomenti):tipo risultato …

Operazioni e metodi Funzioni o trasformazioni applicate agli oggetti della classe Tutti gli oggetti della classe condividono le stesse operazioni Ogni operazione opera su un oggetto che può essere implicito o esplicito Un metodo è l’implementazione di una operazione Esempio: classe File, operazione print, metodi per stampare file ASCII, binari etc. Polimorfismo: un modo per scegliere il metodo è legato al numero e tipo degli argomenti (sovrapposizione=overloading) Esempio: print(file_name) vs. print(file_pointer) Polimorfismo: il metodo è scelto sulla base dell’oggetto (aggiramento=overriding)

Un primo metodo: il costruttore della classe
Inizializza le variabili Ciclo di vita di una variabile locale: nello ‘scope’ in cui e’ definita Ciclo di vita di una variabile dinamica: programma Quando viene generata una variabili di tipo classe, si attiva automaticamente una funzione che inizializza le variabili della classe: costruttore Quando la variabile termina il suo ciclo di vita viene attivata automaticamente -se disponibile- una funzione di eliminazione: distruttore (ad esempio delete di variabili nella memoria libera) Costruttore: funzione con lo stesso nome della classe non richiede tipo di ritorno puo’ avere una lista di argomenti di inizializzazione attivata automaticamente quando si crea un'oggetto con new sono possibili costruttore diversi, che devono avere liste di argomenti diversi costruttore di default: senza argomenti.

Relazioni tra oggetti e classi
Collegamenti e associazioni Associazione: gruppo di collegamenti con struttura comune Vengono lette in una particolare direzione: I nomi indicano il ruolo di una classe all’interno di una associazione Si interpreta: Stato - HaCapitale - Città Un collegamento è una istanza di una associazione Tipicamente realizzati mediante puntatori HaCapitale CapitaleDi Stato Città Diagramma delle classi nome nome

Relazioni tra oggetti e classi: associazione
Molteplicità del ruolo della classe Descrive quante istanze di una classe possono relazionarsi ad una singola istanza della classe associata Simboli terminatori: 1  uno e solo uno 0..1  zero o uno (opzionale) M..N  da M a N *  0 o più (molti) 0..*  0 o più (molti) 1..*  1 o più (molti) Esempio: punti di intersezione su una linea. Associazione molti-a-molti. Si interpreta: Linea si relaziona con molti Punti; Punto si relaziona con 2 o più Linee Linea Punto 2..* * nome nome

Relazioni tra oggetti e classi: associazione
Persona Nome Indirizzo Codice fiscale Data di nascita marito moglie dirigente dipendente 0..1 * Società Nome indirizzo 1 * Persona Nome Indirizzo Codice fiscale Data di nascita Datore lavoro impiegato 1..* * 1..* 0..1 persona casa città possiede Situata in * 3..* * 2 poligono linea punto ha lati

Relazioni tra oggetti e classi: associazione n-aria
Esempio di diagramma delle classi Titolo -nome -autore -isbn -numeroPrenotazioni +inserisci +rimuovi +cerca Libro -id +inserisci +rimuovi +cerca 0..* 0..1 Rivista -durataPrestito Prestito Data=dataCorrente +inserisci +rimuovi +cerca 0..* Prenotazione -Data=dataCorrente +inserisci +rimuovi +cerca 0..* Cliente Nome Indirizzo Cerca Inserisci rimuovi 0..*

Relazioni tra oggetti e classi: associazione n-aria
Le associazioni binarie legano due classi. Una classe può legarsi a n classi  associazione n-aria. Simbolo: + 1..* 1 studenti Insegnante Corso Data_inizio Data_fine 1 1 * Aula Giorno e ora Lezione argomento

Aggregazione: Esprime la forza della associazione o tra classi. Simbolo: Puramente logico Sia il tutto che le parti esistono indipendentemente Asimmetrico, bidirezionale, transitivo Composizione: più forte della aggregazione. Simbolo: Le parti esistono solo in relazione al tutto genitore figlio Persona Persona 0..2 * Automezzo Motore 1 1

Aggregazione Rappresenta un tipo di contenimento tra classi
Contenimento lasco: B = contenitore, A = contenuto Contenimento lasco: ciclo di vita oggetto contenuto e contenitore indipendenti il contenitore non è responsabile della creazione e della distruzione dell’oggetto si realizza mediante un puntatore al contenuto il coordinatore dell’aggregazione deve: Creare oggetto contenuto Definire e inizializzare un puntatore ad esso Costruire oggetto contenitore passando puntatore al contenuto

Composizione Rappresenta un tipo di contenimento tra classi
Contenimento stretto: B = contenitore, A = contenuto l’oggetto contenuto non ha una vita propria l’oggetto contenitore è responsabile della costruzione e distruzione si realizza con un oggetto contenuto interno al contenitore è responsabilità del coordinatore creare l’oggetto contenitore fornire valori oggetto contenuto il compilatore richiama il costruttore e il distruttore del contenuto

Confronto tra contenimento e derivazione
Consideriamo i due casi: La classe B contiene la classe A (contenimento) La classe B è derivata dalla classe A (ereditarietà) In entrambi i casi l’oggetto B contiene l’oggetto A Interfacce: Contenimento: l’interfaccia di A e B indipendenti Derivazione: interfaccia di B comprende quella di A Ereditarietà più forte del contenimento: B può eseguire overriding delle funzioni di A Un puntatore a B può essere assegnato a puntatore a A Un oggetto B può essere assegnato ad un oggetto A

Esempio di aggregazione tra classi
Carrozzeria NumeroSerie : stringa Colore : enum […] Peso : float Automobile Marca : stringa Modello : stringa Velocità : float Accelerazione : float MuoviAvanti() MuoviIndietro() MarciaSu() Avvia() Motore NumeroSerie : stringa Marca : stringa NumeroValvole : enum[…] NumeroCilindri : enum[…] Peso : float Start : Boolean Carrozzeria e Motore hanno vita propria!! Ogni istanza di Automobile ha una Carrozzeria e un Motore  Contenimento LASCO

Associazioni tra classi
Associazione uno-a-uno associazione Come si realizza? Con un puntatore alla classe associata Ogni classe ha un metodo ‘collegati al partner’ Il coordinatore: Crea oggetti a e b Collega a con b Collega b con a

Associazione uno a uno con indicazione dei ruoli associazione Ruolo di A Ruolo di B Associazione uno a molti associazione Ad un oggetto della classe A corrispondono più oggetti della classe B Ad un oggetto della classe B corrisponde un oggetto di A * Nella classe A c’è una lista di puntatori alla classe B lista statica se si conosce il numero massimo di oggetti altrimenti  lista dinamica

Esempio: associazione Persona-Automobile coproprietario possiede 0..1 guida 0..1 pilota vettura l’associazione ‘possiede’ ha Molteplicità 1 a (0..1) una persona possiede 0 o 1 automobile Una automobile è posseduta da 1 persona Direzionalità: da Persona a Automobile (Automobile non ha traccia della associazione)

l’associazione ‘guida’ ha Molteplicità 1 a (0..1) una persona può guidare 0 oppure 1 automobile Una automobile è guidata da 1 persona Direzionalità: bidirezionale (Automobile e persona hanno traccia della associazione ‘guida’) l’associazione ‘coproprietario’ Riflessiva Molteplicità 0..1 a 0..1

Molteplicità (esempi) coordinatore dipendente Persona Persona Persona nome indirizzo = coordinatore nome indirizzo nome indirizzo dipendente valutazione valutazione Persona Azienda File Utente nome indirizzo nome indirizzo nome nome Stipendio mansione Permessi

Esempio (I) Dato il seguente diagramma degli oggetti tracciare il corrispondente diagramma delle classi Punto -10 10 Punto 10 Poligono Punto -10 Punto 10 -10

Soluzione esempio (I) Diagramma delle classi Note:
3..* Punto x:coordinata y:coordinata Poligono (ordinata) Note: Il più piccolo nr di punti = 3 Associazione ‘ordinata’ = indica che i punti sono in sequenza

Esempio (II) Diagramma degli oggetti per due triangoli con un lato in comune Se un punto appartiene ad un solo triangolo Punto 0,1 Punto -1,0 Punto 1.0 Poligono Punto 0,-1 Punto -1,0 Punto 1.0 Poligono

Esempio (III) Se un punto appartiene ad uno o più triangoli Punto 0,1
Poligono Punto -1,0 Punto 1.0 Poligono Punto 0,-1

Esempio (IV) Diagramma ad oggetti per descrivere grafi non orientati
Grafo non orientato 0..* 0..* 0..* Vertice nome del vertice Lato nome del lato 2

Esempio (V) Diagramma ad oggetti per descrivere grafi orientati
Grafo orientato 0..* 0..* da 0..* Vertice nome del vertice Lato nome del lato a 0..*

Linguaggi di programmazione a oggetti
C++ (Stroustrup ‘83) Ispirato principalmente da Simula67 Java JDK 1.0 (January 23, 1996) JDK 1.1 (February 19, 1997) J2SE 1.2 (December 8, 1998) J2SE 1.3 (May 8, 2000) J2SE 1.4 (February 6, 2002) J2SE 5.0 (September 30, 2004) Java SE 6 (December 11, 2006) Java SE 6 Update 10 Java SE 7

Integrated Developments Environments
Eclipse Jbuilder

Riferimenti (specificatore &)
sinonimi (alias) per lo stesso oggetto il tipo dell’oggetto determina il tipo del riferimento puo’ essere visto come un tipo speciale di puntatore deve essere inizializzato e agisce solo su un oggetto uso principale: argomenti e risultati di una funzione

Uso dei riferimenti come argomenti e risultati di funzione senza passare esplicitamente l’indirizzo
//opp4.cpp #include <iostream.h> int incrementa(int &val) { val++; if(val>65000) val=65000; return 0; } int incrementa(int &val, int v) int t=v; t++; if(t>65000) t=65000; return t; main() int i=7; cout << " i=" << i; incrementa(i); cout << " i=" << i << " i=" << incrementa(i,i) << " i=" << i << '\n'; Output: i=7 i=8 i=9 i=8

Argomenti di default in una funzione
specificatore “inline”: inline void funzione(..) sostituisce il codice della funzione alle chiamate di funzione. : attenzione alla crescita delle dimensioni del codice! campo di visibilità delle dichiarazioni: identificatori: dalla dichiarazione fino alla fine della funzione identificatori globali sono visibili dalla dichiarazione alla fine del file identificatore locale maschera un identificatore globale con un stesso nome Scope o operatore di visibilità “::” à specifica la variabile da utilizzare identificatori locali non sono visibili all'esterno della funzione l’identificatore “::var” identifica la variabile globale blocco: sequenza di istruzioni tra graffe

una funzione e’ un blocco
visibilita’ locale: identificatori definiti all’interno di un blocco visibilita’ a livello di file: funzioni e identificatori definiti fuori da tutte le funzioni visibilita’ degli identificatori di blocchi annidati visibilita’ delle etichette: nel corpo della funzione a cui il blocco appartiene

Le classi in C++ una classe è il modello-prototipo-al quale si conformano gli oggetti che istanziano la classe struttura di una classe: class nome_classe { private: // dati e metodi accessibili solo ai metodi della classe. Sono quindi nascosti all’esterno (non accessibili direttamente) protected: // privati all’esterno; dati e metodi accessibili solo all’interno della classe e tramite classi derivate public: // dati e metodi accessibili pubblicamente a tutte le funzioni dello stesso scope dell’oggetto }; le componenti funzionali dichiarati in una struttura possono essere definite all'interno, (inline) o all'esterno una classe introduce un nuovo tipo di dati

Le classi in C++ il tipo di dato definito con le classi, in cui cioè la struttura interna è inaccessibile, e dal quale si possano istanziare oggetti manipolabili solo per mezzo delle operazione associate, è detto “tipo di dato astratto” (ADT) esempio di tipo di dato astratto “contatore” class contatore { private: unsigned int valore; public: contatore(); //un costruttore void incrementa(); void decrementa(); void set(unsigned int n); unsigned int val(); }; l'implementazione della classe può essere realizzato in un file separato o inline

Un contatore

Le classi in C++ i metodi vengono attivati inviando all'oggetto un messaggio con il nome del metodo usando l’operatore punto “.”: c1.incrementa();//invia all’oggetto c1 la richiesta di attivare //incrementa c1.visualizza();//analogamente Puntatore ad oggetto: operatore freccia a destra “->”:

Le classi in C++ invio di dati ad una procedura vs. invio di un messaggio all'oggetto ma: quando un oggetto riceve un messaggio, determina come deve essere elaborato il dato sottostante usando i metodi associati al dato non posso elaborare direttamente i dati! Es. c1.valore non è possibile i metodi possono essere definiti anche in più file la classe contatore potrebbe anche essere realizzata con una struttura: #include <stdio.h> struct contatore { unsigned int valore; }; main() contatore c1, c2; c1.valore++; c2.valore++; } ma: in questa forma i dati sono pubblici e la funzione principale accede direttamente al dato sottostante

Strutture dati astratte ‘punto’ e ‘stringa’

Le classi in C++ Abstract Data Type : classe punto

Le classi in C++ Costruttori e distruttori delle classi
necessità di inizializzare le variabili ciclo di vita di una variabile locale: nello scope in cui e’ definita ciclo di vita di una variabile dinamica: programma quando viene generata una variabili di tipo classe, si attiva automaticamente una funzione che inizializza le variabili della classe: costruttore: funzione con lo stesso nome della classe non richiede tipo di ritorno; puo’ avere una lista di argomenti attivata automaticamente quando si crea un'oggetto con new sono possibili costruttore diversi, che devono avere liste di argomenti diversi costruttore di default: senza argomenti. quando la variabile termina il suo ciclo di vita viene attivata automaticamente -se disponibile- una funzione di eliminazione: distruttore (ad esempio delete di variabili nella memoria libera) Costruttore di copia: Quando si passa o si ritorna un oggetto ad una funzione In generale quando si copia un oggetto

#include <iostream.h>
// Esempio di costruttori per copia class stringa { int len; char *ch; public: stringa() {cout << "costruttore di default" << endl; len=0;}//costruttore di default stringa(const char *s) //costruttore con argomenti; s e' puntatore a stringa costante { cout << "costr. con argomenti" << endl; len=strlen(s); ch=new char[len+1]; strcpy(ch,s);} stringa(const stringa&s) //costruttore di copia { cout << "costruttore di copia" << endl; len=s.len; ch=s.ch;} void list(){cout<<ch<<endl;} int val(){return len;} void set(int n){len=n;} void setp(char *ps){ch=ps;} }; int lung(stringa s){return s.val();} //usa l'inizializzazione di copia stringa crea(int l) { stringa s; char *ps; s.set(l); ps=new char[l+1]; s.setp(ps); return s;} //usa l’iniz. di copia} main() stringa a; //costruttore di default stringa b("Luigi"); //costruttore con argomenti stringa c=b; //costruttore di copia c.list(); cout << lung(c); a=crea(10); cout << lung(a); } Output: costruttore di default Costr. con argomenti costruttore di copia Luigi costruttore di copia 5 costruttore di default costruttore di copia costruttore di copia 10

Un numero complesso

numeri complessi // #include <stdio.h>
#include <iostream.h> #include <stdlib.h> #include <string.h> class complesso { private: float pr, pi; public: complesso(){pr=0;pi=0;} //costruttore di default complesso(float x,float y); //altro costruttore void cadd(complesso arg); //operazione binaria void csub(complesso arg); //operazione binaria void cmult(complesso arg); void visualizza(); }; // definizione funzioni complesso::complesso(float x, float y) { pr=x; pi=y; } void complesso::cadd(complesso arg) { pr+=arg.pr; pi+=arg.pi; } void complesso::csub(complesso arg) { pr-=arg.pr; pi-=arg.pi; } void complesso::cmult(complesso arg) { float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; pr=temp1; pi=temp2; }

void complesso::visualizza()
{ if(pi<0) cout << '\n' << "complesso: " << pr << "- j" << abs(pi); else cout << '\n' << "complesso: " << pr << "+ j" << pi; } main() complesso a(1,3), b(2,2); complesso *c; c=new(complesso(3.14,1.2)); a.visualizza(); b.visualizza(); c->visualizza(); a.cadd(b); b.cadd(b); a.csub(b); a.cmult(b); Output: complesso: 1+ j3 complesso: 2+ j2 complesso: 3+ j5 complesso: 4+ j4 complesso: -1+ j1 complesso: -8+ j0

ADT nodo ADT lista

//esempio di ADT nodo ADT lista
#include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <string.h> class nodo { private: nodo *next; int valore; public: nodo(){next=NULL;} void loadn(nodo *a){next=a;} void loadv(int a){valore=a;} nodo *getn(){return next;} int getv(){return valore;} }; class lista nodo *head; lista(){head=NULL;} //costruttore ~lista(){} //distruttore: lasciato per esercizio! void insert(int n); //at the top void add(int n); //at the bottom int hremove(); //toglie dalla cima int tremove(); //toglie dalla coda void type(); //visita dalla cima e stampa il contenuto

void lista::insert(int n)
{ nodo *temp; temp=new nodo; temp -> loadv(n); temp -> loadn(NULL); if(head) {temp -> loadn(head); head=temp;} else {temp -> loadn(NULL); head=temp;} } void lista::add(int n) nodo *temp, *prec; if(head){ temp=head; while(temp){ prec=temp; temp=temp->getn(); prec->loadn(new nodo); prec=prec->getn(); prec->loadv(n); prec->loadn(NULL); } else { head=new nodo; head -> loadv(n); head -> loadn(NULL);

int lista::hremove() { int n; if(head){ n=head->getv(); head=head->getn(); return(n); } else return(65536); //65536 means empty } int lista::tremove() nodo *temp, *prec; temp=head; while(temp->getn()) { prec=temp; temp=temp->getn(); n=temp->getv(); prec->loadn(NULL); delete(temp);

void lista::type() { nodo *temp; temp=head; while(temp){ cout << temp->getv() << '\n'; temp=temp->getn(); } main() lista L1, L2; int n; for(int i=0; i<5; i++) L1.insert(i); cout << "L1:" << '\n'; L1.type(); L2.add(10); L2.add(100); cout << "L2:" << '\n'; L2.type(); L1.add(5); L1.add(6); L1.add(7); cout << "L1 after add" << '\n'; L1.type(); cout << "L1hrem " << L1.hremove() << '\n'; while( (n=L2.tremove())!=65536) cout << "L2 trem " << n << '\n'; while( (n=L1.hremove())!=65536) cout << "L1 hrem " << n << '\n';

Le classi in C++ Autoriferimento nelle classi: l'argomento implicito 'this‘ una classe può contenere oggetti di altre classi, puntatori a oggetti di altre classi, puntatori a oggetti della stessa classe (autoriferimento) ogni oggetto contiene un puntatore, chiamato this, che contiene l'indirizzo dell'oggetto stesso Nota: ogni oggetto contiene al proprio interno le variabili definite nella classe, ma non i metodi: ci possono essere molte istanze di una classe ma una sola istanza delle funzioni il puntatore all'oggetto ‘this’ viene passato implicitamente alle funzioni della classe al momento della loro attivazione, per sapere qual è l'oggetto attivatore

Le classi in C++ Esempio di autoriferimento: concatenazione di stringhe #include <iostream.h> class stringa { int len; //dati privati char *str; public: //definizione dei metodi stringa(int=0); stringa(const char *); stringa &concat(const stringa&); char *visualizza(); }; //in questo modo è possibile scrivere: main() stringa a(80); stringa b("sequenza"); stringa c(" di questa"); stringa d(" prova"); a=b.concat(c).concat(d); cout << a.visualizza(); }

//implementazione dei metodi
stringa::stringa(int n) { len=n; if(n>0){ str=new char (len+1); str[0]='\0'; } } stringa::stringa(const char *s) { len=strlen(s); str=new char[len+1]; strcpy(str,s); } char* stringa::visualizza() { return str; } stringa& stringa::concat(const stringa &s) { len += s.len; char *temp=new char[len+1]; strcpy(temp,str); strcat(temp, s.str); //temp="sequenza di questa" str=temp; //str e' la stringa dell'oggetto che ha attivato concat return *this; //ritorna l'oggetto che ha attivato concat } Output: sequenza di questa prova

Le classi in C++ Overloading degli operatori
ridefinizione di simboli del linguaggio notazione infissa anche fra tipi diversi limiti: solo operatori gia’ definiti l’operatore che viene ridefinito conserva le sue caratteristiche di associativita’, precedenza e numero di argomenti almeno uno degli argomenti deve essere di tipo classe non si possono usare operatori che non hanno significato in C (es. **) Specificatore: operator <operatore da sovrapporre> operatore binario: definito da un metodo interno con un argomento - a.add(b) – oppure con due argomenti – a=a.add(a,b) - classe C { priv; ... public: C binary_op(C); C binary_op(C, C); } classe binary_op(classe arg){return classe(priv+arg.priv);} classe binary_op(classe arg1, classe arg2){ return classe(arg1.priv+arg2.priv);} main(){ a.binary_op(b); a=a.binary_op(a,b);

Le classi in C++ Operatori del C++ che possono essere sovrapposti:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || [] () new delete

Le classi in C++ operatore unario: metodo intero ad una classe senza argomenti operatore unario U: l'espressione argomento U oppure U argomento può essere: argomento.U() oppure U(argomento) non è possibile realizzare applicazione prefissa e postfissa /* Uso degli operatori unari e binari */ // #include <iostream.h> void main() { int a=1; int b; cout << "prima a= " << a << '\n'; b = a++; // l'operatore post-incremento e' unario: prima assegna e poi incrementa cout << "dopo a++: a= " << a << " b=" << b <<'\n'; a=1; b = ++a; /* l'operatore pre-incremento e' unario: prima incrementa e poi assegna*/ cout << "dopo ++a: a= " << a << " b=" << b <<'\n'; b = a+1; /* l'operatore somma e' binario: prima somma e poi assegna */ cout << "dopo a+1: a= " << a << " b=" << b <<'\n'; }

Sovrapposizione degli operatori: esempio

Sovrapposizione degli operatori: esempio
overloading di operatori unari #include <iostream.h> // class contatore { unsigned int valore; public: contatore(){valore=0;} void operator++(){if(valore<65535) valore++;}//overloading di ++ void operator--(){if(valore>0) valore--;}//overloading di () void operator()(unsigned int n){if((valore>=0)&&(valore<65535)) valore=n;} unsigned int val(){return valore;} }; main() contatore c1,c2; c2(10); for(short i=0; i<10; i++){ c1++; c2++; } cout << "valore finale di c1=" << c1.val() << " finale di c2=" << c2.val(); Output: Valore finale di c1=10 finale di c2=20

Sovrapposizione operatori e numeri complessi
// #include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <string.h> class complesso { private: float pr, pi; public: complesso(){pr=0;pi=0;} //costruttore di default complesso(float x,float y); //altro costruttore void cadd(complesso arg); //operazione binaria void csub(complesso arg); //operazione binaria void cmult(complesso arg); void visualizza(); }; // definizione funzioni complesso::complesso(float x, float y) { pr=x; pi=y; } void complesso::cadd(complesso arg) { pr+=arg.pr; pi+=arg.pi; } void complesso::csub(complesso arg) { pr-=arg.pr; pi-=arg.pi; } void complesso::cmult(complesso arg) { float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; pr=temp1; pi=temp2; }

{ if(pi<0) cout << '\n' << "complesso: " << pr << "- j" << abs(pi); else cout << '\n' << "complesso: " << pr << "+ j" << pi; } main() complesso a(1,3), b(2,2); a.visualizza(); b.visualizza(); a.cadd(b); b.cadd(b); a.csub(b); a.cmult(b); Output: complesso: 1+ j3 complesso: 2+ j2 complesso: 3+ j5 complesso: 4+ j4 complesso: -1+ j1 complesso: -8+ j0

Overloading operatori e numeri complessi: seconda versione
// #include <iostream.h> #include <math.h> class complesso { private: float pr, pi; public: complesso(){pr=0;pi=0;} //costruttore di default complesso(float x,float y); //altro costruttore complesso cadd(complesso arg); complesso csub(complesso arg); complesso cmult(complesso arg); void visualizza(); }; complesso::complesso(float x, float y){ pr=x; pi=y; } complesso complesso::cadd(complesso arg){complesso t; t.pr=pr+arg.pr; t.pi=pi+arg.pi; return t;} complesso complesso::csub(complesso arg){complesso t; t.pr=pr-arg.pr; t.pi=pi-arg.pi; return t;} complesso complesso::cmult(complesso arg) { complesso t; float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; t.pr=temp1; t.pi=temp2; return t; }

{ if(pi<0) cout << '\n' << "complesso: " << pr << "- j" << abs(pi); else cout << '\n' << "complesso: " << pr << "+ j" << pi; } main() complesso a(1,3), b(2,2); a.visualizza(); b.visualizza(); a=a.cadd(b); b=b.cadd(b); a.visualizza(); b.visualizza(); a=a.csub(b); a.visualizza(); b.visualizza(); a=a.cmult(b); a.visualizza(); b.visualizza();

overloading degli operatori e numeri complessi
// #include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <string.h> class complesso { private: float pr, pi; public: complesso(){pr=0;pi=0;} //costruttore di default complesso(float x,float y); //altro costruttore complesso operator+(complesso arg); complesso operator-(complesso arg); complesso operator*(complesso arg); complesso operator*(float arg); void visualizza(); }; // definizione funzioni complesso::complesso(float x, float y) { pr=x; pi=y; } complesso complesso::operator+(complesso arg) //complesso operator+(complesso b){ { complesso t; t.pr=pr+arg.pr; t.pi=pi+arg.pi; return t;} complesso complesso::operator-(complesso arg) { complesso t; t.pr=pr-arg.pr; t.pi=pi-arg.pi; return t;}

complesso complesso::operator*(complesso arg)
{ complesso t; float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; t.pr=temp1; t.pi=temp2; return t; } complesso complesso::operator*(float arg){ //prodotto con tipo diverso! return complesso(arg*pr, arg*pi); void complesso::visualizza() { if(pi<0) cout << '\n' << "complesso: " << pr << "- j" << abs(pi); else cout << '\n' << "complesso: " << pr << "+ j" << pi; main() complesso a(1,3), b(2,2), c, d; a.visualizza(); b.visualizza(); a=a+b; b=b+b; a.visualizza(); b.visualizza(); a=a-b; a.visualizza(); b.visualizza(); a=a*b; a.visualizza(); b.visualizza(); a=a*2; //attenzione: non e’ possibile 2*a! a.visualizza(); c=a+a; a=((a+b-c)*c)*2; a.visualizza();

La classe A può dichiarare ‘amica’ la classe B

Relazioni tra oggetti e classi: generalizzazione/specializzazione
Mammiferi Cani Gatti

Introducono una gerarchia di classe Generalizzazione: una superclasse fattorizza le proprietà comuni di un insieme di classi Generalizzazione: asimmetrica, non riflessiva, transitiva Simbolo: Classe meno generale Classe più generale classi più generali superclasse Specializzazione Generalizzazione classi più specializzate subclasse

Attributi, operazioni e relazioni della superclasse vengono ereditate dalle sottoclassi se protetti Figura posizione colore display Figura posizione colore display = Arco raggio angolo iniziale ancolo finale display Segmento Coordinate display Rettangolo Vertici display Arco raggio angolo iniziale ancolo finale display Segmento Coordinate display Rettangolo Vertici display

Top-down: Bottom-up: Classe base (componente complesso) Sottoclassi (componenti minime) Automobile ruota carrozzeria motore veicolo Veicolo senza motore a motore moto auto taxi aereo Classe base (componente minimo) Sottoclassi (componenti via via piu’ complesse)

Ereditarietà multipla Veicolo Veicolo a vento Veicolo a motore Veicolo di terra Veicolo d’acqua Camion Barca a vela

Le classi in C++ Costruttori/distruttore nelle classi derivate
legato alla visibilità tra oggetti derivati e oggetti base se un oggetto di classe derivata viene inizializzato, il costruttore deve assicurarsi che venga eseguita una inizializzazione anche dell'oggetto della classe di base-interna alla classe derivata-. il costruttore della classe derivata attiva uno dei costruttore della classe base: class Base { int a; protected: int bb; public: int b; void Base(){a=0;} } class Derivata:public Base int c; Derivata():Base(){c=0;} int funz(){c=c+bb+b+d; return c;} class Derivata2: public Derivata(){... public: derivata2(): Derivata()}

Derivazione (I)

Derivazione (II)

//ESEMPIO DI CLASSE BASE
//file complesso.h class complesso { protected: float pr, pi; public: complesso(){pr=0;pi=0;} //costruttore di default complesso(float x,float y); //altro costruttore void add(complesso arg); void sub(complesso arg); void mpy(complesso arg); void visualizza(); }; // definizione funzioni complesso::complesso(float x, float y) { pr=x; pi=y; } void complesso::add(complesso arg) //complesso operator+(complesso b){ co { pr=pr+arg.pr; pi=pi+arg.pi; } void complesso::sub(complesso arg) { pr=pr-arg.pr; pi=pi-arg.pi; } void complesso::mpy(complesso arg) { float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; pr=temp1; pi=temp2; } void complesso::visualizza() { if(pi<0) cout << '\n' << "pr,pi " << pr << "- j" << abs(pi); else cout << '\n' << "pr,pi " << pr << "+ j" << pi; }

#include <stdlib.h> #include <math.h> #include "complesso.h" class comp:public complesso { private: float modulo; //valori trigonometrici float fase; public: comp(float x, float y):complesso(x, y) //costruttore modulo=sqrt(x*x+y*y); fase=atan(y/x); } void c2t() float x=pr; float y=pi; modulo=sqrt(x*x+y*y); fase=atan(y/x); void t2c() { pr=modulo*cos(fase); pi=modulo*sin(fase); } void mult(comp arg) { modulo=modulo*arg.modulo; fase=fase+arg.fase; } void div(comp arg) { modulo=modulo/arg.modulo; fase=fase-arg.fase; } void visualizza() { complesso::visualizza(); cout << " modulo=" << modulo << " fase=" << fase;} }; main() comp a(1,1); comp b(1,2); a.visualizza(); b.visualizza(); a.mult(b); a.t2c(); a.visualizza(); a.div(b); a.t2c(); a.visualizza();

// //derivazione #include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <string.h> class complesso { protected: float pr, pi; public: complesso(float x,float y); //altro costruttore complesso cadd(complesso arg); complesso csub(complesso arg); void visualizza(); }; // definizione funzioni complesso::complesso(float x, float y) pr=x; pi=y; } complesso complesso::cadd(complesso arg) pr+=arg.pr; pi+=arg.pi;

complesso complesso::csub(complesso arg)
{ pr-=arg.pr; pi-=arg.pi; } void complesso::visualizza() cout << '\n' << "complesso: " << pr << "+ j" << pi; class comp: public complesso //derivazione per estendere la classe public: comp(float x, float y):complesso(x, y){};//costruttore comp cmult(comp arg); comp cdiv(comp arg); void visualizza(char a); }; // comp comp::cmult(comp arg) float temp1, temp2; temp1=pr*arg.pr - pi*arg.pi; temp2=pr*arg.pi + pi*arg.pr; pr=temp1; pi=temp2;

comp comp::cdiv(comp arg)
{ float temp, temp1, temp2; temp=arg.pr*arg.pr + arg.pi*arg.pi; temp1 = (pr*arg.pr + pi*arg.pi)/temp; temp2 = (pr*arg.pi - pi*arg.pr)/temp; pr=temp1; pi=temp2; } void comp::visualizza(char a) cout << '\n' << a; complesso::visualizza(); main() comp a(1,2), b(2,2); a.complesso::visualizza(); b.complesso::visualizza(); a.cadd(b); b.cadd(b); a.visualizza('a'); b.visualizza('b'); a.csub(b); a.cmult(b); a.visualizza('a'); b.cdiv(b); b.visualizza('b');

Derivazione (III)

// liste derivate #include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <string.h> #include <alloc.h> class nodo { protected: nodo *next; int valore; public: nodo(){next=NULL;valore=0;} void loadpun(nodo *a){next=a;} nodo *getpun(){return next;} void loadval(int a){valore=a;} int getval(){return valore;} }; class nodo_ext: public nodo char *nome; int flag; nodo_ext(char *n, int f):nodo(){strcpy(nome,n);flag=f;} nodo_ext():nodo(){flag=0;nome="";} void loadnome(char *n){nome=new char[strlen(n)+1]; strcpy(nome,n);} char *getnome(){return nome;} void loadflag(int a){flag=a;} int getflag(){return flag;}

class lista { private: nodo_ext *head; public: lista(){head=NULL;} //costruttore void add(int val, char *n, int f); //at the bottom int tremove(); //toglie dalla coda e restituisce il nome void type(); //visita dalla cima e stampa il contenuto }; void lista::add(int val, char *n, int f) nodo_ext *temp, *prec; if(head){ temp=head; while(temp){ prec=temp; temp=(nodo_ext *)temp->getpun(); } prec->loadpun(new nodo_ext); prec=(nodo_ext*)prec->getpun(); prec->loadval(val); prec->loadflag(f); prec->loadnome(n); prec->loadpun(NULL); } else { head=new nodo_ext; head -> loadval(val); head -> loadflag(f); head -> loadnome(n); head -> loadpun(NULL);

int lista::tremove() { int n; nodo_ext *temp, *prec; temp=head; if(head){ while(temp->getpun()) { prec=temp; yemp=(nodo_ext*)temp->getpun(); } n=temp->getval(); prec->loadpun(NULL); delete(temp); return(n); } else return(65536); //65536 means empty } void lista::type() nodo_ext *temp; while(temp){ cout << "val=" << temp->getval() << " nome=" << temp->getnome() << " flag=" cout << temp->getflag() << '\n'; temp=(nodo_ext*)temp->getpun(); main() lista L1, L2; int n; for(int i=0;i<5;i++) L1.add(i,"primo",0); L1.type(); cout << "inizio a rimuovere dalla coda" << '\n'; while((n=L1.tremove())!=65536) cout << "remove L1 " << n << '\n';

Derivazione (IV) Derivazione multipla

Regole di visibilita’ Classe base (superclasse) à classe derivata (sottoclasse) Ricerca di una componente interna ad una variabile di sottoclasse: Prima nella sottoclasse - Poi nelle componenti ereditate Funzioni ridefinite nella sottoclasse:nasconde la funzione della superclasse Tutte le funzioni sono ancora attive! Si possono chiamare o con casting – ((superclasse) oggetto sottoclasse).funzione – o con Oggetto_sottoclasse.superclasse::funzione Riprendiamo la classe Studente. l’abbinamento funzione-oggetto e’ fatto STATICAMENTE dal compilatore (all’atto della compilazione) sulla base di tipo oggetto e argomenti Ma: con i puntatori?

Regole di visibilita’ Puntatori:
Studente *giorgio; Persona *giulio; giorgio=new Studente(“Giorgio Bianchi", "ingegneria", 23,4); giorgio -> presentati(); Attenzione: i puntatori possono puntare a oggetti diversi! giulio=giorgio; giulio->presentati(); // la associazione e’ fatta sulla base del // tipo del puntatore e non dell’oggetto!! giulio e’ una persona ma punta ad uno studente! delete giulio cancella solo la persona: spreco spazio Funzioni virtuali: associazione sulla base del tipo di oggetto

//oop45.cpp #include <iostream.h> class Persona { protected: int eta; char *nome; public: Persona(const char *n, int e){ nome=new char[strlen(n)+1]; strcpy(nome,n); eta=e;} virtual void presentati() cout << "sono una persona, mi chiamo " << nome << " ed ho " << eta << " anni“ << endl; } }; class Studente:public Persona private: int anno; char *facolta; Studente(char *n, char *f, int e, int a):Persona(n,e) { facolta=new char[strlen(f)+1]; strcpy(facolta,f); anno=a; } virtual void presentati(){ cout<<"sono uno studente di nome "<<nome<<" ho "<<eta<<" anni e sono iscritto a "<<facolta<<" al "<<anno<<" anno di corso" << endl;

main() { Persona mario("Mario Verdi", 22); Studente luigi("Luigi Rossi", "ingegneria", 24, 5); mario.presentati(); luigi.presentati(); Studente *giorgio; Persona *giulio; giorgio=new Studente("Giorgio Bianchi", "ingegneria", 23,4); giorgio -> presentati(); giulio=giorgio; giulio->presentati(); } Output con funzioni virtuali: sono una persona, mi chiamo Mario Verdi ed ho 22 anni sono uno studente di nome Luigi Rossi ho 24 anni e sono iscritto a ingegneria al 5 anno di corso sono uno studente di nome Giorgio Bianchi ho 23 anni e sono iscritto a ingegneria al 4 anno di corso sono uno studente di nome Giorgio Bianchi ho 23 anni e sono iscritto a ingegneria al 4 anno di corsOutput o Output senza funzioni virtuali sono una persona, mi chiamo Mario Verdi ed ho 22anni sono una persona, mi chiamo Giorgio Bianchi ed ho 23anni

Le classi in C++ Polimorfismo e funzioni virtuali
Polimorfismo: capacità di rispondere in modo differenziato agli stessi comandi à realizzato con overloading delle funzioni e con le funzioni virtuali overloading delle funzioni: la scelta della funzione da attivare è effettuata esaminando una lista degli operandi o il tipo di oggetti tramite cui vengono operate le richieste alle operazioni abbinamento statico(static binding): deciso alla compilazione abbinamento dinamico(dynamic binding): deciso in run-time overloading quando gli oggetti vengono rappresentati con puntatore: i puntatori possono puntare a oggetti di tipo diverso! ma l'abbinamento statico si basa sul tipo di puntatore e non sul tipo di oggetto puntato! funzione virtuale: funzione il cui abbinamento con l'oggetto è fatto in run-time sintassi: virtual int funz(){ }

Le classi in C++ una funzione definita virtuale nella classe base in una gerarchia di derivazione, rende virtuali tutte le funzioni con stesso prototipo e componenti la classe derivata l'abbinamento dinamico oggetto-funzione con le funzioni virtuali funziona solo se gli oggetti sono gestiti con puntatore. Se l'oggetto gestito con il nome, l'associazione e' statica. tre casi in cui la chiamata di una funzione virtuale è risolta staticamente: quando la chiamata e’ effettuata con un oggetto e non con un puntatore quando si usa scope (::) alla classe nella chiamata con puntatore quando una funzione virtuale è chiamata all'interno di costruttore o distruttore costruttori e distruttori virtuali Un costruttore non puo’ essere mai dichiarato virtuale (deve essere dichiarato prima) Distruttori possono essere virtuali!

Vantaggi del polimorfismo
Permette di scrivere codice generico che si adatta automaticamente alle specializzazioni future Permette di creare nuovi metodi senza cambiare il resto del codice Semplice estensione del codice pre-esistente  riutilizzabilita’ del codice Attenzione: se l’impostazione e’ corretta, si puo’ cambiare molto lavorando poco… …se si modifica troppo il codice originale, l’impostazione e’ sbagliata! Modifiche concentrate  migliore manutenzione Attenzione: i vantaggi si pagano con una certa perdita di efficienza!

class SuperficiePiana { protected: float dim1; public: SuperficiePiana(float d) {dim1=d;} virtual void presentati() { cout << “Sono una superficie piana, la mia prima dimensione e' " << dim1 ; } virtual float Area(){ return 0;} }; class triangolo: public SuperficiePiana private: float dim2; triangolo(float d1, float d2) : SuperficiePiana(d1) { dim2=d2; } { cout<<“Sono un triangolo di dimensioni " << dim1 <<" e " << dim2 ; } virtual float Area(){ return dim1*dim2/2.; } class cerchio: public SuperficiePiana cerchio(float d1):SuperficiePiana(d1) {} { cout<< “Sono un cerchio" ; } virtual float Area(){ return 3.14 * dim1*dim1; }

main() { SuperficiePiana * f1; f1=new SuperficiePiana(2.); f1->presentati(); cout << ". La mia area = " << f1->Area() << endl; f1=new triangolo(2.,4.); } //============================================================================ // aggiunta della classe trapezio class trapezio:public SuperficiePiana { private: float dim2; float dim3; public: trapezio(float d1, float d2, float d3):SuperficiePiana(d1) {dim2=d2;dim3=d3;} void presentati() { cout << "sono un trapezio con basi=" << dim1 << ", " << dim2 << " e altezza= " << dim3 ; } float Area(){return (dim1+dim2)*dim3/2; } };

Ricapitolando … Campo variabili privato Una classe (ADT): Metodo1
class casa { ... }; Un oggetto e’ una istanza della classe: casa a; Piu’ oggetti hanno diversi valori delle variabili e stesso comportamento Piu’ oggetti hanno diverse variabili, il codice e’ rientrante: casa a, mia, tua; mia.metodo1; //attiva metodo1 mediante l’invio dell’indirizzo di mia al codice di metodo1 Comunicazione tra oggetti tramite invio di messaggi di attivazione Campo variabili Metodo1 Metodo2 Metodo3 privato pubblico ogg.a ogg. mia ogg. tua Codice dei metodi Puntatore ‘this’

Ricapitolando … Comunicazione tra oggetti Campo variabili Metodo1
Chiama tua.metodo2 Campo variabili Metodo1 Metodo2 Metodo3 a Campo variabili Metodo1 Metodo2 Metodo3 tua Chiama mia.metodo1 mia

Ricapitolando … Terminologia:
Classe derivata: classe ottenuta mediante specializzazione di un’altra classe Classe base: la classe dalla quale una classe è derivata Ereditarietà: una classe derivata eredita da una classe base Ereditarietà impropria: quando la classe base ha una capacità che la classe derivata non può soddisfare (esempio: nella derivazione struzzo:uccello la classe base ha un metodo vola()) Costruttori/distruttori: inizializzazione var-rilascio spazio Istanziazione oggetto/terminazione oggetto nome uguale alla classe, senza return parametri opzionali, possibili costruttori multipli Costruttore di default / di copia Attenzione: l’inizializzazione del costruttore segue l’ordine di definizione variabili

Ricapitolando … Ereditarietà Esempio: Relazione has-a (composizione)
Relazione is-a (specializzazione/derivazione) Esempio: Se il problema si descrive con la frase: …un veicolo contiene una o più ruote…  Implementare la classe ‘ruota’ e poi la classe ‘veicolo’: class veicolo{ private: Ruota r1,r2,r3; } Se si descrive con la frase: …un’auto è un veicolo…  Implementare la classe ‘veicolo’ e poi la classe ‘auto’: class auto:public veicolo{ private: } auto *a=new auto(); veicolo *v=new veicolo(); v=a; //lecito a=v; //errato

Ricapitolando … Array di oggetti:
il costruttore e il distruttore vengono chiamati per ciascun elemento dell'array per un vettore di oggetti appartenenti ad una classe con un costruttore, la classe deve avere un costruttore senza argomenti Costruttori/distruttore nelle classi derivate legato alla visibilità tra oggetti derivati e oggetti base se un oggetto di classe derivata viene inizializzato, il costruttore deve assicurarsi che venga eseguita una inizializzazione anche dell'oggetto della classe di base-interna alla classe derivata-. il costruttore della classe derivata attiva uno dei costruttore della classe base

Ricapitolando … Polimorfismo: Funzioni virtuali:
Capacità degli oggetti di differenti classi legate da ereditarietà di rispondere differentemente alla stessa chiamata Ottenuto mediante overloading delle funzioni e funzioni virtuali Abbinamento statico delle funzioni agli oggetti Statico: legato al tipo del puntatore, non al tipo dell’oggetto puntato ‘casting’ per indicare esplicitamente il tipo del puntatore Funzioni virtuali: Abbinamento dinamico della funzione all’oggetto I costruttori NON possono essere virtuali I distruttori possono invece esserlo: recuperano lo spazio dell’oggetto puntato

Ricapitolando … Funzioni virtuali come base per la derivazione:
Non definiscono il contenuto di alcuni metodi: Public: virtual void stampa(){ }; Funzioni virtuali pure Definite ma mai utilizzate per istanziare oggetti Dichiarate con uno zero: Public: virtual void stampa() = 0; Classe che contiene una o più funzioni virtuali pure : classe astratta (indica com’è fatta la classe in modo astratto) Usata come base per la derivazione Non è possibile istanziare da una classe astratta Una classe astratta è una interfaccia per la derivazione

Polimorfismo e funzioni virtuali
Polimorfismo: capacità di rispondere in modo differenziato agli stessi comandi à realizzato con overloading delle funzioni e con le funzioni virtuali overloading delle funzioni: la scelta della funzione da attivare è effettuata esaminando una lista degli operandi o il tipo di oggetti tramite cui vengono operate le richieste alle operazioni abbinamento statico(static binding): deciso alla compilazione abbinamento dinamico(dynamic binding): deciso in run-time overloading quando gli oggetti vengono rappresentati con puntatore: i puntatori possono puntare a oggetti di tipo diverso! ma l'abbinamento statico si basa sul tipo di puntatore e non sul tipo di oggetto puntato! funzione virtuale: funzione il cui abbinamento con l'oggetto è fatto in run-time

Polimorfismo e funzioni virtuali
Una funzione definita virtuale nella classe base in una gerarchia di derivazione, rende virtuali tutte le funzioni con stesso prototipo e componenti la classe derivata L'abbinamento dinamico oggetto-funzione con le funzioni virtuali funziona solo se gli oggetti sono gestiti con puntatore. Se l'oggetto gestito con il nome, l'associazione e' statica. Tre casi in cui la chiamata di una funzione virtuale è risolta staticamente: quando la chiamata e’ effettuata con un oggetto e non con un puntatore quando si usa scope (::) alla classe nella chiamata con puntatore quando una funzione virtuale è chiamata all'interno di costruttore o distruttore Costruttori e distruttori virtuali Un costruttore non puo’ essere mai dichiarato virtuale (deve essere dichiarato prima) Distruttori possono essere virtuali!

Vantaggi del polimorfismo
Permette di scrivere codice generico che si adatta automaticamente alle specializzazioni future Permette di creare nuovi metodi senza cambiare il resto del codice Semplice estensione del codice pre-esistente  riutilizzabilita’ del codice Attenzione: se l’impostazione e’ corretta, si puo’ cambiare molto lavorando poco… …se si modifica troppo il codice originale, l’impostazione e’ sbagliata! Modifiche concentrate  migliore manutenzione Attenzione: i vantaggi si pagano con una certa perdita di efficienza!

Polimorfismo (I)

Polimorfismo (II)

Lista non polimorfica senza friend

Lista non polimorfica con friend

Inserimento di una categoria aggiuntiva nella lista non polimorfica

Lista polimorfica

// //lista polimorfica. Header file #include <iostream.h> class persona { friend class lista; protected: char cognome[10]; char nome[10]; int anni; int codice_fiscale; persona *ptr; persona *next; public: persona(char *co, char *no, int a, int cf); persona(); ~persona(); void set_cognome(char *c); void set_nome(char *n); void set_anni(int a); void set_cf(int cf); virtual void stampa(); virtual void insert(); };

//(continua) class studente:public persona { friend class lista; private: int matricola; int anno_di_corso; public: studente(char *co, char *no, int a, int cf, int mat, int an):persona(co, no, a, cf) { matricola=mat; anno_di_corso=an; } studente():persona() { matricola=0; anno_di_corso=0;} void set_matricola(int m); void set_anno_corso(int ac); void stampa(); void insert(); }; class lavoratore:public persona { friend class lista; float stipendio; lavoratore(char *co, char *no, int a, int cf, float s):persona(co, no, a, cf){stipendio=s;} lavoratore():persona() { stipendio=0;} void set_stipendio(float s); void stampa(); void insert();

//(continua) class pensionato:public persona { friend class lista; private: int anni_quiescenza; public: pensionato(char *co, char *no, int a, int cf, int q):persona(co, no, a, cf) { anni_quiescenza=q; } pensionato():persona() { anni_quiescenza=0;} void set_quiescenza(int q); void stampa(); void insert(); }; class lista persona *radice; lista(); ~lista(); void inserisci(persona *n); void rimuovi(char *c); void stampa();

//Lista polimorfica //Implementazione dei metodi della lista polimorfica #include <iostream.h> #include "lista4.h" persona::persona(char *co, char *no, int a, int cf) { strcpy(cognome,co); strcpy(nome,no);anni=a; codice_fiscale=cf; next=0; } persona::persona() { strcpy(cognome,"\0"); strcpy(nome,"\0"); anni=0; codice_fiscale=0; next=0; } persona::~persona(){}; void persona::set_cognome(char *c) { strcpy(cognome,c); } void persona::set_nome(char *n) { strcpy(nome,n); } void persona::set_anni(int a) { anni=a; } void persona::set_cf(int cf) { codice_fiscale=cf; } void persona::insert() { ptr=new persona(cognome, nome, anni, codice_fiscale); } void persona::stampa() { cout << cognome << " " << nome << "\t anni " << anni << " CF= " << codice_fiscale ;} void studente::set_matricola(int m) { matricola=m; } void studente::set_anno_corso(int ac) { anno_di_corso=ac;} void studente::stampa() { persona::stampa(); cout << " Studente, matricola=" << matricola << " anno di corso="<<anno_di_corso<<endl; } void studente::insert() { ptr=new studente(cognome, nome, anni, codice_fiscale, matricola, anno_di_corso); }

//Lista polimorfica void lavoratore::set_stipendio(float s) { stipendio=s; } void lavoratore::stampa() { persona::stampa(); cout << " Lavoratore, stipendio=" << stipendio <<endl; } void lavoratore::insert() { ptr=new lavoratore(cognome, nome, anni, codice_fiscale, stipendio); } void pensionato::set_quiescenza(int q) { anni_quiescenza=q;} void pensionato::stampa() { persona::stampa(); cout << " Pensionato, anni di quiescenza=" << anni_quiescenza <<endl;} void pensionato::insert() { ptr=new pensionato(cognome, nome, anni, codice_fiscale, anni_quiescenza); } lista::lista() { radice=0; } lista::~lista() { // naturalmente per cancellare lo spazio degli oggetti bisogna avere una lista // bidirezionale. Si lascia per esercizio persona *p,*q; do{ p=q=radice; while(p->next!=0){q=p;p=p->next;} q->next=0; delete p; } while(q!=radice); delete radice; }

//(continua). Lista polimorfica
void lista::inserisci(persona *n) { persona *p, *q; p=q=radice; n->insert(); if(p==0) {p=radice=n->ptr;} else { while(p!=0){q=p; p=p->next;} q->next=n->ptr; } } void lista::rimuovi(char *c) {// in questo esempio non e' stata scritta. Si lascia per esercizio } void lista::stampa() persona *p; p=radice; while(p!=0) { p->stampa(); p=p->next; } main() lista l; persona t; studente st("Terreni", "Piero", 30, 2222, 23, 5); lavoratore la("Pierucci", "Piero", 40, 1111, 2000); pensionato pen("Rossi", "Luigi", 70, 3276, 5); l.inserisci(&st); l.inserisci(&la); l.inserisci(&pen); l.stampa();

//Introduzione di una classe aggiuntiva. Lista polimorfica
//Introduzione di una classe aggiuntiva. Lista polimorfica. Header file lista5.h #include <iostream.h> class persona { friend class lista; protected: char cognome[10];char nome[10];int anni;int codice_fiscale;persona *ptr;persona *next; public: persona(char *co, char *no, int a, int cf); persona(); ~persona(); void set_cognome(char *c); void set_nome(char *n); void set_anni(int a); void set_cf(int cf); virtual void stampa(); virtual void insert(); }; class studente:public persona private: int matricola; int anno_di_corso; studente(char *co, char *no, int a, int cf, int mat, int an):persona(co, no, a, cf) { matricola=mat; anno_di_corso=an; } studente():persona() { matricola=0; anno_di_corso=0;} void set_matricola(int m); void set_anno_corso(int ac); void stampa(); void insert();

//lista5.h (continua) class lavoratore:public persona { friend class lista; private: float stipendio; public: lavoratore(char *co, char *no, int a, int cf, float s):persona(co, no, a, cf) { stipendio=s; } lavoratore():persona() { stipendio=0;} void set_stipendio(float s); void stampa(); void insert(); }; class pensionato:public persona int anni_quiescenza; pensionato(char *co, char *no, int a, int cf, int q):persona(co, no, a, cf) { anni_quiescenza=q; } pensionato():persona() { anni_quiescenza=0;} void set_quiescenza(int q); void stampa(); void insert();

//lista5.h (continua) Classe aggiunta nell’header file
class disoccupato:public persona { friend class lista; private: int mesi_disoccupazione; int nr_impieghi; public: disoccupato(char *co, char *no, int a, int cf, int md, int ni):persona(co, no, a, cf) { mesi_disoccupazione=md; nr_impieghi=ni; } disoccupato():persona() { mesi_disoccupazione=0; nr_impieghi=0; } void set_disoccupazione(int md) { mesi_disoccupazione=md; } void set_impieghi(int ni) { nr_impieghi=ni; } void stampa() { persona::stampa(); cout << " Disoccupato da " << mesi_disoccupazione; cout << " mesi. Nr. impieghi=" << nr_impieghi << endl; } void insert() { ptr=new disoccupato(cognome,nome,anni,codice_fiscale,mesi_disoccupazione,nr_impieghi); }; }; class lista { private: persona *radice; lista(); ~lista(); void inserisci(persona *n); void rimuovi(char *c); void stampa();

//implementazione dei metodi della lista polimorfica
#include <iostream.h> #include "lista5.h" persona::persona(char *co, char *no, int a, int cf) { strcpy(cognome,co); strcpy(nome,no); anni=a; codice_fiscale=cf; next=0; } persona::persona() { strcpy(cognome,"\0"); strcpy(nome,"\0"); anni=0; codice_fiscale=0; next=0; } persona::~persona(){}; void persona::set_cognome(char *c) { strcpy(cognome,c); } void persona::set_nome(char *n) { strcpy(nome,n); } void persona::set_anni(int a) { anni=a; } void persona::set_cf(int cf) { codice_fiscale=cf; } void persona::insert() { ptr=new persona(cognome, nome, anni, codice_fiscale); } void persona::stampa() { cout << cognome << " " << nome << "\t anni " << anni << " CF= " << codice_fiscale ;} void studente::set_matricola(int m) { matricola=m; } void studente::set_anno_corso(int ac) { anno_di_corso=ac;} void studente::stampa() { persona::stampa(); cout << " Studente, matricola=" << matricola << " anno di corso="<<anno_di_corso<<endl; } void studente::insert() { ptr=new studente(cognome, nome, anni, codice_fiscale, matricola, anno_di_corso); }

//(continua) void lavoratore::set_stipendio(float s) { stipendio=s; } void lavoratore::stampa() { persona::stampa(); cout << " Lavoratore, stipendio=" << stipendio <<endl; } void lavoratore::insert() { ptr=new lavoratore(cognome, nome, anni, codice_fiscale, stipendio); } void pensionato::set_quiescenza(int q) { anni_quiescenza=q;} void pensionato::stampa() { persona::stampa(); cout << " Pensionato, anni di quiescenza=" << anni_quiescenza <<endl;} void pensionato::insert() { ptr=new pensionato(cognome, nome, anni, codice_fiscale, anni_quiescenza); } lista::lista() { radice=0; } lista::~lista() persona *p,*q; do{ p=q=radice; while(p->next!=0){q=p;p=p->next;} q->next=0; delete p; } while(q!=radice); delete radice; } void lista::inserisci(persona *n) { persona *p, *q; p=q=radice; n->insert(); if(p==0) {p=radice=n->ptr;} else { while(p!=0){q=p; p=p->next;} q->next=n->ptr; } void lista::rimuovi(char *c) {// in questo esempio non e' stata scritta. Si lascia per esercizio }

//(continua) void lista::stampa() { persona *p; p=radice; while(p!=0) { p->stampa(); p=p->next; } } main() lista l; persona t; studente st("Terreni", "Piero", 25, 2222, 23, 5); lavoratore la("Pierucci", "Piero", 40, 1111, 2000); pensionato pen("Rossi", "Luigi", 70, 3276, 5); disoccupato dis("Ferri", "Luigi", 40, 2323, 8, 1); l.inserisci(&st); l.inserisci(&la); l.inserisci(&pen); l.inserisci(&dis); l.stampa();

Esempio di calcolo con i polinomi mediante programmazione ad oggetti

class CFunction{ public: CFunction(){ if (dbg) cout << "Costruttore classe base CFunction" << endl;} virtual ~CFunction(){ if (dbg) cout << "Distruttore classe base CFunction" << endl;} virtual double GetY(double x) = 0; }; class CPoly: public CFunction{ protected: int Order; //Grado del polinomio double *Coeffs; CPoly(); //C default crea ma non definisce ordine e coefficienti CPoly(int g, double* c); //C numeratore grado g e coefficienti di *c, denominatore 1 CPoly(const CPoly& p); //C di copia CPoly(int g, double c); //costruttore di polinomio grado 0 coeff=c ~CPoly(); //Distruttore void Visualizza()const; //stampa CPoly &operator=(const CPoly& p); CPoly operator+(const CPoly& p); CPoly operator-(const CPoly& p); CPoly operator*(const CPoly& p); int GetOrder(); double GetCoeffs(int i); bool nullo(); //verifica se il polinomio è nulloù bool unitario(); double GetY(double x){}

class CPolyF: public CPoly{ //definisce polinomio base
protected: char *nome; //nome del polinomio int OrderF; //Grado del polinomio double *CoeffsF; //Vettore di coefficienti public: CPolyF(); //C default crea ma non definisce ordine e coefficienti CPolyF(int g, double* c); //C numeratore grado g e coefficienti di *c, denominatore 1 CPolyF(int g, double* c, int gF, double *cF); //C numeratore grado g e coefficienti di *c, denominatore 1 CPolyF(const CPolyF& p); //C di copia CPolyF(const CPoly& a, const CPoly& b); //C per parti CPolyF(const CPoly& a); //C polinomi interi ~CPolyF(); //Distruttore void Visualizza()const; //stampa CPolyF &operator=(const CPolyF& p); //assegnazione CPolyF operator+(const CPolyF& p); //somma CPolyF operator-(const CPolyF& p); //differenza CPolyF operator*(const CPolyF& p); //moltiplicazione CPolyF operator/(const CPolyF& p); //divisione void SetNome(char *n); //assegna il nome al polinomio void SetNum(CPoly n); void SetDen(CPoly d); char* GetNome(); void Semplifica(); //ricerca fattori semplificabili //CPoly GetDen(); double GetY(double x){} //friend class CPolyF; };

CPoly::CPoly(int g, double* c){ //Costruttore
int i=0; for (i=g; i>0; i--){ //i coefficienti sono congruenti con il grado? if (c[i]==0) g--; else break; }//end for Order=g; if (g>=0){ Coeffs=new double[g+1]; for (i=0; i<=g; i++){ Coeffs[i]=c[i]; } else Coeffs=NULL; CPoly::~CPoly(){ //distruttore if (Coeffs) delete [] Coeffs; //se è definito CoeffsF lo dealloca void CPoly::Visualizza()const{ if (Order<0){ //polinomio definito? cout << "Polinomio non definito" << endl; return; }//end if stampa(Order, Coeffs); //stampa del solo numeratore //e stampa il risultato cout << endl; //a capo CPoly &CPoly::operator=(const CPoly& p){ if (Order!=p.Order){ if (Coeffs) delete [] Coeffs; Order=p.Order; Coeffs=new double[Order+1]; //copia dei coefficienti for (int i=0; i<=Order; i++) Coeffs[i]=p.Coeffs[i]; if (dbg) cout << "\nOperatore CPoly =" << endl; return *this;

CPolyF::CPolyF():CPoly(){ //Costruttore di default
nome=NULL; OrderF=-1; //denominatore CoeffsF=NULL; //nè per numeratore nè per denominatore if (dbg) cout << "C CPolyF default" << endl; //debug } CPolyF &CPolyF::operator=(const CPolyF& p){ //se gli ordini sono diversi si devono riallocare i coefficienti if (Order!=p.Order){ if (Coeffs) delete [] Coeffs; //deallocando i precedenti Order=p.Order; //acquisendo il nuovo ordine Coeffs=new double[Order+1]; //e allocando quelli nuovi } //copia dei coefficienti for (int i=0; i<=Order; i++) Coeffs[i]=p.Coeffs[i]; if (OrderF!=p.OrderF){ if (CoeffsF) delete [] CoeffsF; //deallocando i precedenti OrderF=p.OrderF; //acquisendo il nuovo ordine CoeffsF=new double[OrderF+1]; //e allocando quelli nuovi for (int i=0; i<=OrderF; i++) CoeffsF[i]=p.CoeffsF[i]; if (dbg) cout << "\nOperatore CPolyF =" << endl; return *this;

CPolyF CPolyF::operator-(const CPolyF& p){
CPolyF ris; bool den_uguali=true; CPoly *n1, *d1, *n2, *d2; if (OrderF==p.OrderF){ for (int i=0; i<=p.OrderF; i++){ if (CoeffsF[i]!=p.CoeffsF[i]) den_uguali=false; } if (den_uguali){ n1=new CPoly(Order, Coeffs); n2=new CPoly(p.Order, p.Coeffs); d1=new CPoly(OrderF, CoeffsF); ris=CPolyF((*n1)-(*n2),(*d1)); delete n1, n2, d1; return ris; } n1=new CPoly(Order, Coeffs); d1=new CPoly(OrderF, CoeffsF); n2=new CPoly(p.Order, p.Coeffs); d2=new CPoly(p.OrderF, p.CoeffsF); ris=CPolyF((*n1)*(*d2)-(*n2)*(*d1),(*d1)*(*d2)); delete n1 , n2, d1, d2; CPolyF CPolyF::operator+(const CPolyF& p){ CPolyF ris; bool den_uguali=true; CPoly *n1, *d1, *n2, *d2; if (OrderF==p.OrderF){ for (int i=0; i<=p.OrderF; i++){ if (CoeffsF[i]!=p.CoeffsF[i]) den_uguali=false; } if (den_uguali){ n1=new CPoly(Order, Coeffs); n2=new CPoly(p.Order, p.Coeffs); d1=new CPoly(OrderF, CoeffsF); ris=CPolyF((*n1)+(*n2),(*d1)); delete n1, n2, d1; return ris; } n1=new CPoly(Order, Coeffs); d1=new CPoly(OrderF, CoeffsF); n2=new CPoly(p.Order, p.Coeffs); d2=new CPoly(p.OrderF, p.CoeffsF); ris=CPolyF((*n1)*(*d2)+(*n2)*(*d1),(*d1)*(*d2)); delete n1, n2, d1, d2;

CPolyF CPolyF::operator*(const CPolyF& p){
CPolyF ris; bool n1_d2_uguali=true; bool n2_d1_uguali=true; CPoly *n1, *d1, *n2, *d2; if (Order==p.OrderF){ //controllo uguaglianza num1-den2 for (int i=0; i<=p.OrderF; i++){ if (Coeffs[i]!=p.CoeffsF[i]){ n1_d2_uguali=false; break; } else n1_d2_uguali=false; if (n1_d2_uguali){ n1=new CPoly(0, 1); d2=new CPoly(0, 1); else{ n1=new CPoly(Order, Coeffs); d2=new CPoly(p.OrderF, p.CoeffsF); } //fine uguaglianza num1-den2 if (OrderF==p.Order){ //controllo uguaglianza num2-den1 for (int i=0; i<=p.Order; i++){ if (CoeffsF[i]!=p.Coeffs[i]){ n2_d1_uguali=false; else n2_d1_uguali=false; if (n2_d1_uguali){ n2=new CPoly(0, 1); d1=new CPoly(0, 1); n2=new CPoly(p.Order, p.Coeffs); d1=new CPoly(OrderF, CoeffsF); } //fine uguaglianza num2-den1 ris=CPolyF((*n1)*(*n2),(*d1)*(*d2)); delete n1, n2, d1, d2; return ris;

Esempio di calcolo vettoriale mediante programmazione ad oggetti

#include <iostream.h> //stream di input e output
#include <stdlib.h> //libreria standard #include <conio.h> //console di input e output #include <math.h> //libreria con funzioni matematiche (radice) typedef int inte; //Il vettore é di tipo intero class matrix //classe matrice { //definita da righe,colonne e dove sono colocate friend class vettore; //classe vettore può usare oggetti matrice protected: //protette per derivazione int r,c; //variabili numero righe(r) e colonne(c) int **m; //doppio puntatore public: matrix(int a,int b); //costruttore con argomenti numero righe e colonne matrix(matrix& y); //costruttore copia virtual inte& accedi(int i,int j); //accesso alle variabili:ne restituisce il valore matrix operator+(matrix& mat); //somma di 2 matrici;overloading di + matrix operator-(matrix& mat); //sottrazione di 2 matrici;overloading di - matrix operator*(matrix& mat); //moltiplicazione di 2 matrici;overloading di * void errore(char c[]); //segnala l'errore e esci dal programma virtual void stampa(char *s1); //visualizza la matrice };//matrix matrix::matrix(int a,int b) //costruttore { r=a; //assegna numero di righe c=b; //assegna numero di colonne m=new inte*[r]; //crea un "oggetto" di r puntatori,poi ad ogni puntatore for(int i=0;i<r;i++) //alloca una diversa riga m[i]=new inte[c]; //l'i-esimo elemento di m(per ogni riga) diventa }//for i //un nuovo elemento di colonna }//costruttore

class matrice_quad:public matrix //matrice quadrata,sottoclasse di matrice:è un esempio di derivazione { //questo programma non richiede la dichiarazione friend,poiché nel main la classe vettore private: //non usa oggetti matrice_quad bool sim,diag; //variabili simmetrica e diagonale public: matrice_quad(int a,int b,bool si,bool dia):matrix(a,b) //costruttore che prende in { //derivazione numero di righe e di colonne(=righe) dal costruttore della superclasse matrice sim=si; //inizializzate le variabili simmetrica e diagonale diag=dia; }//costruttore matrice_quad(matrice_quad& x):matrix(x) //costruttore copia con derivazione { //delle protected di matrice e sim=x.sim; //private di matrice quadrata diag=x.diag; }//costruttore copia void check_sim(); //controlla se simmetrica void check_dia(); //controlla se diagonale inte& accedi(int i,int j); //accedi alle variabili void errore(char c[]); //segnala l'errore e esci dal programma void stampa(char *s1); //visualizza la matrice quadrata };//matrice_quad class vettore //classe vettore { //definita dal numero di elementi(size) e dove sono collocati(*p) private: int size; //quanti elementi ci sono inte *p; //dove sono questi elementi vettore(int n); //costruttore con argomento numero di elementi vettore(vettore& v); // costruttore copia inte& operator[](int i); //accesso all'elemento i-esimo vettore operator+(vettore& v); //somma di 2 vettori;overloading di + vettore operator-(vettore& v); //sottrazione di 2 vettori;overloading di - inte operator*(vettore& v); //prodotto scalare;overloading di * inte operator|(vettore& v); //calcolo del modulo del vettore;overloading di | vettore molt_per_matrice(vettore& v,matrix& mat); //moltiplicazione di 1 vettore per una matrice void scrivi(char *s1); //visualizza il vettore };//vettore

matrix matrix::operator+(matrix& mat) //somma di matrici con overloading
{ matrix loc(mat); //crea una copia locale di matrice if(mat.r!=r) //se il numero delle righe delle 2 matrici non coincide mat.errore("matrici con numero di righe incompatibili"); //messaggio di errore }//if if(mat.c!=c) //se il numero delle colonne delle 2 matrici non coincide mat.errore("matrici con numero di colonne incompatibili"); //messaggio di errore for(int i=0;i<r;i++) //ciclo di riga for(int j=0;j<c;j++) //ciclo di colonna loc.m[i][j]=m[i][j]+mat.m[i][j]; //somma gli elementi delle 2 matrici }//for j }//for i return loc; //restituisci la matrice "somma" }//operator+ matrix matrix::operator-(matrix& mat) //sottrazione di matrici con overloading if(mat.c!=c) //se il numero delle colonne delle 2 matrici non coincide loc.m[i][j]=m[i][j]-mat.m[i][j]; //sottrai agli elementi,quelli della matrice in entrata return loc; //restituisci la matrice "differenza" }//operator-

matrix matrix::operator
matrix matrix::operator*(matrix& mat) //moltiplica 2 matrici;overloading di * { matrix loc(mat); //crea una copia locale di matrice if(c!=mat.r) //se il numero di colonne della prima é diverso dal { //numero di righe della seconda mat.errore("Errore!Matrici incompatibili per il prodotto"); //messaggio di errore }//if for(int i=0;i<r;i++) //finché ho righe da completare for(int j=0;j<mat.c;j++) //finché ho colonne da completare loc.m[i][j]=0; //azzero il valore degli elementi for(int k=0;k<mat.r;k++) //finché ho righe della matrice in entrata { //faccio la somma del prodotto dell'elemento di riga i e colonna k loc.m[i][j]=loc.m[i][j]+m[i][k]*mat.m[k][j]; //per l'elemento di riga k e colonna j della }//for k //matrice in entrata }//for j }//for i return loc; //restituisci la matrice "prodotto" }//operator* void matrix::stampa(char *s1) //visualizza { cout << "la matrice " << s1 << ": \n"; for(int i=0;i<r;i++) //finché ho righe for(int j=0;j<c;j++) //finché ho colonne cout << m[i][j] << ' '; }//for j cout << '\n'; //vai a capo }//for i }//stampa void matrice_quad::stampa(char *s1) //visualizza { matrix::stampa(s1); //chiama la stampa di matrix passandogli la stringa s1 cout << "quadrata di ordine " << r << 'x' << c << " " ; //aggiungi le informazioni check_sim(); //su simmetrica e check_dia(); //diagonale }//stampa

vettore::vettore(int n) //costruttore di vettore a n elementi
{ size=n; //assegna il numero di elementi p=new inte[n]; //crea un vettore di n elementi }// costruttore inte& vettore::operator[](int i) //accesso all'i-esimo elemento del vettore;overloading di [] { if((i<0)||(i>=size)) //se l'indice è sbagliato cout << "L'indice del vettore é errato!"; //messaggio di errore }//if return (p[i]); //restituisci l'elemento i-esimo }//operator[] vettore vettore::operator+(vettore& v) //somma 2 vettori;overloading di + vettore loc(v); //crea una copia locale del vettore in entrata if(v.size != size) //se il numero di elementi dei 2 vettori non coincide v.errore("I vettori sono incompatibili e non si possono sommare"); //messaggio di errore for(int i=0; i<size;i++) //finché ho elementi loc.p[i]=p[i]+v.p[i]; //aggiungo il corrispondente elemento della }//for //matrice in entrata return loc; //restituisci il vettore "somma" }//operator+ vettore vettore::operator-(vettore& v) //sottrazione di vettori;overloading di - vettore loc(v); //crea copia locale di vettore in entrata if(v.size!=size) //se il numero di elementi dei 2 vettori non coincide v.errore("I vettori sono incompatibili e non si possono sottrarre"); //messaggio di errore for(int i=0;i<size;i++) //finché ho elementi loc.p[i]=p[i]-v.p[i]; //sottraggo dagli elementi del vettore,quelli del }//for //vettore in entrata return loc; //restituisci il vettore "differenza" }// operator-

inte vettore::operator
inte vettore::operator*(vettore& v) //prodotto scalare dei vettori;overloading di * { if(v.size!=size) //se il numero di elementi dei 2 vettori non coincide v.errore("I due vettori sono incompatibili e non si possono moltiplicare"); //messaggio di errore }//if inte s=0; //inizializza e azzera il valore del prodotto scalare for(int i=0;i<size;i++) //finché ho elementi s=s+p[i]*v.p[i]; //somma il prodotto dell'elemento i-esimo del }//for //vettore con lo stesso del vettore in entrata return s; //restituisci il valore del prodotto scalare }//operator* inte vettore::operator|(vettore& v) //calcola il modulo del vettore inte a=0; //inizializza e azzera il valore del modulo del vettore a=a+v.p[i]*v.p[i]; //somma i quadrati di tutti gli elementi }//for return sqrt(a); //restituiscine la radice }//operator| vettore vettore::molt_per_matrice(vettore& v,matrix& mat) //moltiplica un vettore { //per una matrice vettore loc(v); //crea una copia locale del vettore in entrata if(size!=mat.r) //se il numero di elementi del vettore è diverso { //dal numero di righe della matrice v.errore("Errore!Il prodotto tra vettore e matrice non é possibile!"); //messaggio di errore for(int i=0;i<size;i++) //finché ho elementi nel vettore loc.p[i]=0; //azzero il valore dell'elemento i-esimo del vettore risultante for(int k=0;k<mat.r;k++) //finché ho righe della matrice in entrata loc.p[i]=loc.p[i]+p[k]*mat.m[k][i]; //sommo il prodotto dell'elemento }//for k //k-esimo del vettore con l'elemento }//for i //di riga k e colonna i della matrice return loc; //restituisci il vettore "prodotto" V x M }//molt_per_matrice

void main() //esempio di main
{ //definizione variabili vettore v1(d),v2(d); //costruisce 2 vettori di dimensione d //leggi i valori dei vettori cin >> v1[i]; //inserisco i valori degli elementi del primo vettore da tastiera cin >> v2[i]; //inserisco i valori degli elementi del secondo vettore da tastiera // v1=v1+v2; //somma i 2 vettori v1=v1-v2; //sottrai i 2 vettori dato=v1*v2; //moltiplica i 2 vettori dato=v1|v1; //calcola il modulo del primo vettore matrix m1(h,k); //crea l'oggetto matrice m1 //leggi i valori della matrice cin >> m1.accedi(i,j); //assegna i valori consecutivi a m1 matrix m2(a,b); //crea l'oggetto matrice m2 //leggi i valori cin >> m2.accedi(i,j); //assegna i valori consecutivi a m2 m1=m1+m2; //somma m1 con m2,assegna il risultato a m1 m1=m1-m2; //sottrai m2 a m1,assegna il risultato a m1 m1=m1*m2; //moltiplica m1 con m2,assegna il risultato a m1 v1=v1.molt_per_matrice(v1,m1); //moltiplica v1 per m1,assegna il risultato matrice_quad t(h,h,0,0),t1(h,h,0,0); //costruisci 2 matrici quadrate cin >> t.accedi(i,j); //inserisci i valori della prima cin >> t1.accedi(i,j); //inserisci i valori della seconda }//main

Esempio di utilizzo scrivi il numero di elementi dei vettori:3
scrivi i valori del primo vettore:1 2 3 scrivi i valori del secondo vettore:4 5 6 il vettore v1: 1 2 3 il vettore v2: 4 5 6 dopo la somma v1 modificato=v1+v2 il vettore v1: 5 7 9 dopo la differenza v1 modificato=v1-v2 il vettore v1: 1 2 3 Il prodotto scalare di v1 vale 32 Il modulo di v1 é:3 Scrivi rispettivamente il numero di righe e di colonne della prima matrice:3 3 scrivi i valori della prima matrice: 1 2 3 4 5 6 7 8 9 la matrice m1: Scrivi rispettivamente il numero di righe e di colonne della seconda matrice:3 3 scrivi i valori della seconda matrice: 9 8 7 6 5 4 3 2 1 la matrice m2: dopo la somma m1 modificata=m1+m2 la matrice m1: ...

Introduzione alla programmazione ad oggetti

Presentazioni simili

Presentazione sul tema: "Introduzione alla programmazione ad oggetti"— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back

Entrare

Autorizzarsi attraverso i social network:

Introduzione alla programmazione ad oggetti

Presentazioni simili

Presentazione sul tema: "Introduzione alla programmazione ad oggetti"— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back