Calcolatori Elettronici III

Politecnico di Torino sede di Alessandria Calcolatori Elettronici III ing. Dino Canonico dip. di Automatica e Informatica telefono: 011 564 7036 posta elettronica: dino@polito.it

Indice Parte I dai linguaggi procedurali al paradigma ad oggetti Introduzione Linguaggi procedurali Linguaggi ad oggetti Classi Ereditarietà Ridefinizione Classi virtuali Parte II: implementazione C++ Implementazione C++ Il costrutto class Regole di visibilità Implementazione dei metodi Costruttori e distruttori Overloading dei metodi Allocazione statica di oggetti Allcoazione dinamica di oggetti Ereditarietà in C++ Overloading degli operatori Slide 3 9 13 42 47 65 68 72 73 74 79 82 86 89 91 105 111

implementazione C++ il C++ implementa i meccanismi del paradigma ad oggetti con costrutti appositi le classi descrivono le potenzialità degli oggetti da essi instanziati vengono supportati i meccanismi di ereditarietà (semplice e multipla) data hiding overloading di operatori e funzioni vengono mantenuti inoltre i costrutti e le caratteristiche del linguaggio C

il costrutto class... il costrutto class definisce una classe è idealmente simile al costrutto struct del C, con due differenze sostanziali permette di raggruppare in una struttura non solo variabili ma anche funzioni permette di dividere le variabili e li funzioni in pubbliche (visibili ed utilizzabili da elementi esterni alla classe) e private (utilizzabili solo all interno della classe) viene scritto all interno di un file (generalmente.h), eventualmente insieme al resto del codice

.. il costrutto class... esempio sia data una classe che modelli un semplice contatore, capace di incrementare e decrementare il proprio valore fornire il proprio valore all esterno se ne scriva l implementazione C++

.. il costrutto class... dichiarazione del nome dichiarazione componenti private class counter int valore; public: void incrementa (); void decrementa (); int leggi (); dichiarazione componenti pubbliche

.. il costrutto class le definizioni delle componenti pubbliche e private seguono la sintassi del costrutto struct l insieme delle componenti pubbliche della classe corrisponde all interfaccia della classe stessa le componenti private sono invece funzioni e variabili di servizio, utilizzabili liberamente all interno della classe e quindi da metodi (funzioni) sia pubblici che privati, ma vengono nascosti agli utilizzatori terzi della classe questo procedimento si dice data hiding

regole di visibilità gli elementi (metodi e membri) di una classe possono essere dichiarati come public: visibili a chi fa uso della classe private: visibili solo alla classe stessa ma invisibili all esterno i membri possono anche esseer definiti protected: sono visibili alla classe stessa e alle classi che ereditano da essa le variabili comuni mantengono le regole di visibilià del C

funzioni friend è possibile definire funzioni che, pur essendo esterne ad una classe, ne possono manipolare i valori privati queste funzioni, pur essendo definite all interno dell interfaccia della classe non ne fanno parte queste funzioni devono essere definite tramite la keyword friend è possibile definire friend anche intere classi è una metodologia molto usata nel campo dell overloading degli operatori

implementazione dei metodi... dopo aver definito i metodi pubblici e privati occorre scriverne l implemetazione i membri vengono implementati separatamente rispetto alla definizione della classe e vi si collegano tramite la dichiarazione <nome_classe>:: anteposta al nome del metodo

.. implementazione dei metodi... si scriva l implementazione dei metodi della classe counter void counter::incrementa () valore ++; void counter::decrementa () valore ; int counter::leggi () return valore;

.. implementazione dei metodi i metodi vengono implementati all interno del listato tutti i metodi (pubblici e privati) possono "maneggiare" le variabili pubbliche e private all esterno però sono visibili solo i metodi pubblici e le variabili (o membri o attributi) pubbliche

costruttori e distruttori... la maniera nella quale vengono create le istanze di una classe non è automatica, ma va specificata in un apposito metodo (o in una apposita serie di metodi) detto costruttore allo stesso modo, alla fine dell elaborazione, le variabili oggetto allocate devono liberare le risorse impiegate nelle modalità espresse dal distruttore in una classe possono esistere più costruttori, tra i quali chi istanzia l oggetto (il programmatore) sceglie volta per volta quello che ritiene opportuno, ma un solo distruttore

.. costruttori e distruttori... il costruttore che non richiede alcun parametro in ingresso è detto costruttore di default il costruttore viene richiamato automaticamente se non si fa una allocazione esplicita discorso è analogo per quanto riguarda il distruttore i costruttori hanno lo stesso nome della classe, il distruttore ha lo stesso nome della classe preceduto dal simbolo tilde costruttori e distruttore non hanno un valore di ritorno

.. costruttori e distruttori class counter... public: counter (); counter (int); ~counter ();... counter::counter () printf ("costruttore\n"); valore = 0; counter::counter (int init) printf ("costruttore a %d\n", init); valore = init; counter::~counter () printf ("distruttore\n");

membri statici di una classe un membro statico di una classe è un membro in cui indirizzo è condiviso da tutte le istanze della classe in questione class counter static valore; public: void incrementa (); void decrementa (); int leggi (); int counter::valore = 0 counter c1 valore counter c1 counter c1

overloading dei metodi... è possibile che una classe abbia più metodi, identici per quanto riguarda nome e tipo del valore di ritorno, ma che accettino in ingresso parametri diversi questo comportamento (detto polimorfismo o overloading dei metodi) aggiunge flessibiltà agli oggetti scritti in C++

.. overloading dei metodi class counter... nome e valore di ritorno non cambiano public: void reset (); void reset (int);... cambiano invece i parametri in gioco

primo programma completo #include <stdio.h> class counter int valore; public: counter (); counter (int); ~counter (); void incrementa (); void decrementa (); int leggi (); void reset (); void reset (int); ; file counter.h counter::counter () printf ("chiamo il costruttore\n"); valore = 0; counter::counter (int val) printf ("chiamo il costruttore a valore %d\n", val); valore = val; counter::~counter () printf ("chiamo il distruttore\n"); Void counter::incrementa () valore ++; void counter::decrementa () valore ; int counter::leggi () return valore; void counter::reset () valore = 0; void counter::reset (int val) valore = val;

allocazione statica di oggetti... come le variabili allocate staticamente nel C gli oggetti possono essere allocati staticamente nel C++ i membri e i metodi pubblici sono accessibili con una sintassi simile a quella utilizzata per le strutture void main () counter c1, c2 (20);... c1.incrementa (); printf ("valore di c2: %d\n", c2.leggi ());

.. allocazione statica di oggetti #include <stdio.h> #include "counter.h" file myprogram.cpp void main () counter c1, c2 (10); c1.incrementa (); c1.incrementa (); printf ("c1 vale %d\n", c1.leggi ()); c2.reset (20); printf ("c2 vale %d\n", c2.leggi ()); shell di sistema dino ~/docs/poli/c3> gcc myprogram.cpp dino ~/docs/poli/c3>./a.out chiamo il costruttore chiamo il costruttore a valore 10 c1 vale 2 c2 vale 20 chiamo il distruttore chiamo il distruttore dino ~/docs/poli/c3>_

allocazione dinamica di oggetti... come anche le variabili del C, nel C++ è possibile allocare dinamincamente gli oggetti mediante l utilizzo di puntatori come nel C è necessario riservare esplicitamente la memoria da utilizzare; a differenza del C non si usa la funzione malloc (int) ma la keyword new, seguita dai parametri del costruttore per deallocare un oggetto non si usa la funzione free ma il costrutto delete, che invoca il distruttore specifico per la classe

.. allocazione dinamica di oggetti... anche in questo caso la sintassi è simile a quella usata per le strutture void main () counter *c1, *c2; c1 = new counter (); c2 = new counter (10);... c2 >incrementa (); printf ("valore di c1: %d\n", c1 >leggi ());... delete c1; delete c2;

.. allocazione dinamica di oggetti file myprogram.cpp #include <stdio.h> #include "counter.h" void main () counter *c1; counter *c2; c1 = new counter; c2 = new counter (10); c1 >incrementa (); c1 >incrementa (); printf ("c1 vale %d\n", c1 >leggi ()); c2 >reset (20); printf ("c2 vale %d\n", c2 >leggi ()); delete c1; delete c2; shell di sistema dino ~/docs/poli/c3> gcc myprogram.cpp dino ~/docs/poli/c3>./a.out chiamo il costruttore chiamo il costruttore a valore 10 c1 vale 2 c2 vale 20 chiamo il distruttore chiamo il distruttore dino ~/docs/poli/c3>_

creazione per copia normalmente gli oggetti vengono creati mediante l uso degli appositi costruttori esiste però un meccanismo collaterale detto "creazione per copia" che permette di creare un clone di un oggetto questo si ottiene utilizzando l oggetto da clonare come parametro del costruttore dell oggetto da creare void main () counter c1, c2 (10), c3 (c2);...

passaggio di parametri per valore e per riferimento... analogamente al C un oggetto può essere passato per valore o per riferimento: nel primo caso la funzione destinazione elabora una copia dell oggetto passato, nel secondo ne manipola effettivamente il contenuto valgono le stesse considerazioni fatte a suo tempo per il C (un puntatore passato per valore è come una variabile passata per riferimento...)

.. passaggio di parametri per valore e per riferimento void test::aumenta (counter c) c.incrementa (); void test::aumenta (counter* c) c >incrementa (); void main () counter c1, c2 (10); test t;... t.aumenta (c1); t.aumenta (&c2);

Esercizio... si implementi in C++ la classe Stringa, che permetta di inizializzare una stringa vuota, oppure di inizializzare una stringa a partire da un array di caratteri conoscere la lunghezza della stringa confrontare la stringa con un array di caratteri dato (uguale/diversa) trasformare i caratteri minuscoli in maiuscoli concatenare la stringa con un altra data

.. esercizio #include <string.h> #include <malloc.h> class Stringa char* valore; int dimensione; public: Stringa (); Stringa (char *); ~Stringa (); int lunghezza (); int ugualea (char *); void inmaiuscolo (); char* leggi (); void concatena (char*); ; Stringa::Stringa () valore = (char*) malloc (0); dimensione = 0; Stringa::Stringa (char *val) valore = (char*) malloc (sizeof (val) + 1); valore [strlen (val) 1] = \0 ; strcpy (valore, val); dimensione = strlen (valore); Stringa::~Stringa () free (valore); int Stringa::lunghezza () return dimensione; int Stringa::ugualeA (char* val) if (strcmp (val, valore) == 0) return 0; else return 1; void Stringa::inMaiuscolo () for (int a = 0; a < dimensione; a ++) if (valore [a] <= z && valore [a] >= a ) valore [a] = valore [a] a + A ; char* Stringa::leggi () return valore; void Stringa::concatena (char* altro) strcat (valore, altro); dimensione = strlen (valore);

esercizio si scriva il programma teststring che svolga le seguenti operazioni: allocazione statica e dinamica di due oggetti Stringa inizializzazione degli stessi dove necessario manipolazione distruzione dove necessario

Esercizio... si scrivano le classi ritenute necessarie per implementare un sistema di archivio produttori / prodotti / ordini si identifichino i produttori mediante nome e indirizzo si identifichino i prodotti mediante nome si identifichino gli ordini in base a produttore, prodotto ordinato e quntità di quest ultimo per semplicità si assuma che ogni ordine comprenda un solo prodotto

.. esercizio ordine prodotto produttore quantità produttore prodotto getnome () getindirizzo () getnome ()

Esercizio... si scrivano le classi necessarie per implementare un simulatore di pizzeria, comprendente clienti, tavoli, camerieri e forno si assuma per semplicità che non esistano tavoli separati ma un unica tavolata e che i clienti arrivino singolarmente si prevedano per ogni classe parametri che descrivano il comportamento della classe stessa con il passare del tempo

..esercizio... class cliente int preferenza; int pazienza_minuti; int pasto_minuti; public: cliente (int, int); ~cliente (); class cameriere tavolo servizio; public: cameriere (tavolo); ~cameriere (); void interroga_cliente (cliente); void passa_ordine (forno); class tavolo int n_posti; int n_posti_liberi; public: tavolo (int); ~tavolo (); void occupa (); void rilascia (); int get_num_posti_liberi (); class forno int tempo_preparazione; int *coda; public: forno (); ~forno (); void accoda (int); void prepara (int);

..esercizio classe cliente ogni cliente ha una preferenza sulla pizza da scegliere e questa è codificata con un numero intero. Inoltre ha un determinato "tempo di pasto" che è quello durante il quale occupa un posto di un tavolo classe tavolo un tavolo è caratterizzato dal numero totale di posti e dal numero di quelli liberi classe cameriere ogni cameriere è assegnato ad un tavolo (ipotesi semplicistica) il cameriere può interrogare un cliente sulle sue preferenze e passare l ordinazione così ad un forno classe forno un forno può accettare una serie di ordinazioni e accodarle in un array è caratterizzato inoltre da un tempo tipico di preparazione

ereditarietà in C++... secondo il paradigma ad oggetti, è possibile da una classe generale derivare una classe più particolare, aggiungendo nuovo metodi o ridefinendone alcuni della classe principale la classe derivata eredita dalla classe principale tutti i membri (anche quelli privati) tutti i metodi propri della classe tranne costruttori e distruttori overloading di operatori

.. ereditarietà in C++ per definire che una classe ne estende un altra occorre modificare il costrutto class in particolare occorre definire le regole che indichino quali parti originariamente private sono "raggiungibili" dalle classi derivate e quali no

esempio class scaffale int altezza, larghezza; int numero_ripiani; public: scaffale (); ~scaffale (); eredita da... void setaltezza (int); void setlarghezza (int); void setnumeroripiani (int); int getaltezza (void); int getlarghezza (void); int getnumeroripiani (void); non è il caso di ridefinire i metodi di scaffale class armadio : public scaffale int numero_ante; public: armadio (); ~armadio (); void setnumeroante (int); int getnumeroante (void);

Costruttori nelle classi derivate Se una classe B deriva da una classe A, può essere necessario dover invocare un costruttore specifico della classe A e non quello di default. In questo caso si specifica la chiamata al construttore richiesto direttamente nella definizione del costruttore della classe derivata La chiamata al costruttore della classe A va indicata immediatamente dopo la definizione del costruttore della classe B e va preceduta da un carattere ":"

Esempio... si scriva una classe veicolo che esporti i seguenti metodi: int leggi_num_ruote (void); int leggi_peso (void); si scriva una classe auto che aggiunga alla classe veicolo il metodo int leggi_num_posti (void);

file veicolo.h... esempio class veicolo int num_ruote; int peso; public: veicolo (int, int); ~veicolo (); int leggi_num_ruote (void); int leggi_peso (void); ; veicolo::veicolo (int r, int p) num_ruote = r; peso = p; veicolo::~veicolo (void) return; int veicolo::leggi_num_ruote (void) return num_ruote; #include "veicolo.h" file automobile.cpp class automobile : public veicolo int num_posti; public: uutomobile (int, int, int); ~automobile (); int leggi_num_posti (); ; automobile::automobile (int nruote, int peso, int nposti) :veicolo (nruote, peso) num_posti = nposti; int veicolo::leggi_peso (void) return peso; automobile::~automobile () int automobile::leggi_num_posti () return num_posti; richiesta di un costruttore specifico

Overloading degli operatori... è possibile definire il comportamento degli operatori standard del C per compiere operazioni specifiche su particolari oggetti il comportamento di un operatore si definisce come un metodo, con nome dato dall operatore stesso e preceduto dalla keyword operator generalmente è richiesta la dichiarazione friend dell operatore per poter maneggiare i dati interni

.. overloading degli operatori (esempio) class complex private: int real; int imag; public:... friend complex operator + (complex, complex);... ;... complex operator + (complex a, complex b) complex temp; temp.real = a.real + b.real; temp.imag = a.imag + b.imag; return temp;