Michele Tomaiuolo Fondamentidi informatica Oggetti C++

(1)

uolo – Fondamenti di informaticauolo – Fondamenti di informatica gneria dell'informazione – UniPRegneria dell'informazione – UniPR w.ce.unipr.it/people/tomamic/w.ce.unipr.it/people/tomamic/

Oggetti C++

Fondamenti di informatica

Michele Tomaiuolo

tomamic@ce.unipr.it

http://www.ce.unipr.it/people/tomamic

(2)

maiuolo – Fondamenti di informaticamaiuolo – Fondamenti di informatica gegneria dell'informazione – UniPRIngegneria dell'informazione – UniPR /www.ce.unipr.it/people/tomamic//www.ce.unipr.it/people/tomamic/

Oggetto

Astrazione per un oggetto fisico o un concetto (in problema, o soluzione) caratterizzato da:

Uno stato interno (memorizzato in campi)

Un insieme di servizi esposti agli altri oggetti (realizzati come metodi)

Una identità

(diversa locazione in memoria)

Fields (state)

Methods

(3)

Classi ed oggetti

Nei linguaggi class-based, come Java e C++...

Ogni oggetto ha (almeno) una classe di origine

La classe dà la stessa forma (campi e metodi) a tutti i suoi oggetti... ma i valori nei campi sono distinti

Poi, creazione oggetti e invio messaggi

Istanza della classe X ≡ oggetto di classe X

Ogni istanza ha uno stato e una identità (locazione in memoria) distinti...

Anche rispetto ad altre istanze della stessa classe

(4)

Ball: progetto C++

C++: definizione della classe separata dalla

implementazione dei metodi

Definizione fornita agli utenti

Implementazione compilata in libreria

Sorgenti organizzati in 3 file:

ball.h – definizione della classe

ball.cpp – implementazione dei metodi main.cpp – applicazione che usa la classe

Dall'ambiente di sviluppo: Add new → C++ Class

x y

dx

dy getX

getY

move

(5)

#ifndef BALL_H

#define BALL_H class Ball { public:

Ball();

Ball(int x0, int y0, int dx0, int dy0);

void move();

int getX();

int getY();

static const int WIDTH = 16;

static const int HEIGHT = 12;

private:

int x; int y;

int dx; int dy;

};

Definizione: ball.h

Ball

- x : int - y : int - dx : int - dy : int

+ move() : void

Metodi nella sezione “public”

Class diagram UML per rappresentare classi e

relazioni tra classi Class diagram UML per rappresentare classi e

relazioni tra classi

(6)

Implementazione: ball.cpp

#include "ball.h"

Ball::Ball() {

x = WIDTH/2; y = HEIGHT/2; dx = +1; dy = +1;

}

Ball::Ball(int x0, int y0, int dx0, int dy0) { x = x0; y = y0; dx = dx0; dy = dy0;

}

void Ball::move() {

if ((x + dx < 0) || (x + dx >= WIDTH)) { dx = -dx; } if ((y + dy < 0) || (y + dy >= HEIGHT)) { dy = -dy; } x += dx; y += dy;

}

int Ball::getX() { return x; }

int Ball::getY() { return y; }

Nomi dei metodi preceduti dal nome della classe Nomi dei metodi preceduti

dal nome della classe

(7)

#include "ball.h"

/* … */

int main() {

// create a ball: default position and direction Ball ball1;

ball1.move();

cout << ball1.getX() << ", " << ball1.getY() << endl;

// create another ball Ball ball2(8, 4, +1, -1);

ball2.move();

cout << ball2.getX() << ", " << ball2.getY() << endl;

return 0;

Applicazione: main.cpp

(8)

Costruttore

Metodo speciale per impostare lo stato iniziale

Nessun tipo di ritorno

Stesso nome della classe

Prevista una “sezione di inizializzazione”, prima del corpo

Eseguito automaticamente alla creazione di un oggetto

Instantiation is initialization

La creazione di un oggetto deve coincidere con la sua inizializzazione ad uno stato coerente

Ball ball(4, 8, +1, -1);

// Allocazione ed esecuzione costruttore

(9)

Overloading

Possibile definire più funzioni con lo stesso nome

Però con parametri diversi, per numero o tipo Overloading anche per metodi e costruttori

Costruttore di default, senza parametri e vuoto

Creato automaticamente se (e solo se) non esiste

nessun costruttore

(10)

Distruttore

Metodo speciale per liberare risorse

Nome della classe preceduto da ~ , no parametri

Ball::~Ball() {

/* nothing to do! */

}

Se l'oggetto acquisisce risorse, il distruttore le libera

Acquisizione nel costruttore, o in fase successiva Es. apertura file, collegamento di rete, allocazione memoria (new)

Ma, se nessuna risorsa riservata, non serve!

(11)

Metodi getter e setter

A volte si introducono metodi che consentono di manipolare esplicitamente lo stato dell'oggetto

void Ball::setX(int x) { this->x = x; } int Ball::getX() { return x; }

Getter e setter dovrebbero essere minimizzati

Oggetto: ha responsabilità di gestire il suo stato Deve offrire tutti i servizi utili, basati sul suo stato

I metodi getter e setter sono utili soprattutto se

non si limitano a leggere o scrivere variabili

(12)

Metodi e campi di classe

Normalmente, una classe descrive le caratteristiche che avranno le sue istanze

Clausola static: metodi e campi di classe

Non associati ad una particolare istanza

Disponibili anche senza creare alcun oggetto, se preceduti dal nome della classe e “::”

Non possono accedere a parti non-static (metodi e campi di istanza)

Se possibile, evitare! Ma a volte utile:

Definizione costanti, metodi generici, conversioni ecc.

(13)

Creazione e uso di oggetti

Oggetto nello stack (allocazione automatica)

Ciclo di vita limitato allo scope

Oggetto nello heap (allocazione dinamica)

Ciclo di vita gestito esplicitamente con new e delete

Ball b(4, 6, +1, +1); // stack b.move();

Ball* ball = new Ball(8, 2, -1, -1); // heap ball->move();

/* … */

delete ball;

(14)

Puntatore

Ogni dato presente in memoria ha un indirizzo:

variabile puntatore per memorizzarlo

Specificare tipo del dato a cui punta Operatore & per indirizzo di un dato

Op. * per accesso a dato puntato (dereferenziazione)

int i = 56;

int* p; // ptr to int p = &i;

p = p + 1; // ++i

p = NULL; // ptr to nothing

(15)

Puntatori ad oggetti

Ball b1(4, 8, +1, +1);

Ball* b2 = new Ball(4, 12, -1, +1);

Ball* ball; // no object is created!

ball = &b1; // only the address is copied

// warning: b1 is (de)allocated automatically // in future ball may become a dangling ptr ball->move(); // b1.move();

ball = b2; // only the address is copied ball->move(); // b2->move();

In memoria ci sono solo due oggetti Ball In memoria ci sono solo

due oggetti Ball

ball->move() ≡ ball->move() ≡

(16)

Perché i puntatori ad oggetti?

Allocazione e deallocazione decise a runtime, in base a stato dell'applicazione e scelte dell'utente

Ciclo di vita oltre la singola funzione / metodo Copie multiple occupano più memoria

Copie indesiderate impediscono l'accesso condiviso ad uno stesso oggetto (informazione, modifiche...) Rendono possibile il polimorfismo

→ Java: oggetti tutti nello heap, gestiti con riferimenti (simili a ptr); librerie Qt: operano spesso su ptr

Ma... attenzione per allocazione e deallocazione!

(17)

Liberazione della memoria

Creazione oggetto richiede spazio in memoria

Per memorizzare lo stato dell’oggetto ecc.

Liberare questo spazio, quando non serve più!

Oggetti in stack (allocazione automatica)

Oggetto distrutto all'uscita dal blocco o funzione Non conservarne l'indirizzo in alias o puntatori!

Oggetti in heap (allocaz. dinamica, new/delete)

Responsabilità dell'oggetto creatore, oppure…

Responsabilità di chi detiene ultimo riferimento

“Last one out, turns off the light”

(18)

C++: no garbage collection

Vantaggi della garbage collection

Periodicamente la memoria viene liberata e compattata Più difficile dimenticare di liberare la memoria (leak)

Più difficile liberare della memoria che è ancora utilizzata (dangling pointer)

Svantaggi

Il garbage collector decide autonomamente quando liberare la memoria

Oneroso liberare e compattare la memoria

C++2011: garbage collection opzionale

(19)

Relazioni tra classi

Tra classi è possibile stabilire delle relazioni di ereditarietà o specializzazione (is-a)

Le palle sono anche oggetti-moventi (posiz., direz. ecc.) Classe delle palle contenuta (sotto-classe) nella classe degli oggetti-moventi

Oggetto appartenente a più classi, in maniera indiretta

Tra oggetti è possibile stabilire delle relazioni di associazione

Es. un campo-da-gioco aggrega alcuni oggetti-moventi;

un oggetto-movente è composto di pezzi diversi, che

possono essere modellati come oggetti...

(20)

Asynch msg A sends an asynchronous message to B Synch msg A sends a synchronous message to B

UML: relazioni tra classi

Aggregation (has-a) A composes without beloning to B Composition (part-of) A composes and is contained by B Assoc+dir (has-ref-to) You can navigate from A to B

Dependence A depends (param, var, ret-val) upon B Inheritance (is-a) A inherits from B

Generic association A is associated with B

Implementation A has interface B

Realization A is a realization of the abstract class B

A

A A A A A A A A A

B B B B

B B B B B B

(21)

Contenimento

Esprime una associazione di “contenimento fisico”

tra oggetti (part-of, has-a)

Corrisponde ad una composizione, se l'oggetto contenuto non può esistere senza contenitore

… o viceversa ad una aggregazione

In C++ non c’è differenza tra i diversi casi di

contenimento ed una più generica associazione

Wheel Bicycle

2

1

(22)

Composizione

Oggetto: unità di codice che altri ogg. possono usare (riuso in progetti diversi: più difficile)

Inserire un oggetto (member object) dentro un’altro

Nuovo oggetto può contenere vari oggetti, di tipo diverso, per realizzare le sue funzionalità

Grado elevato di flessibilità

Oggetti membri nascosti a chi usa l'oggetto

Modifiche non disturbano il codice esterno

(23)

Associazioni e attributi

Le associazioni vengono usate per collegare tra loro gli oggetti del problema (o della soluzione)

Gli attributi sono di tipo primitivo

Come int o float

Oppure classi delle librerie std (come string)

Spesso si modellano come attributi anche…

Classi di altre librerie che non si vogliono includere esplicitamente nel modello

Classi di base, usate pervasivamente

(24)

Campo da gioco

Realizzare un programma che visualizzi la posizione di varie palle, che si muovo in un campo da gioco

Classi necessarie

Classe delle palle

Classe dei campi da gioco

Possibile usare strutture alternative

Array con dimensione fissa

… riallocazione dinamica

… oppure usare i vector C++

(25)

Navigabilità associazioni

Associazione: può avere nome descrittivo

Ognuno dei lati può avere nome, cardinalità, essere navigabile o no

Solo i lati navigabili vengono implementati

How many fields How many balls

in a field

Ball Field

+ add(ball : Ball) : void + moveAll() : void

1 0..*

balls

(26)

class Field { public:

Field(int width, int height);

~Field();

void add(Ball* b);

void moveAll();

void print();

private:

int width;

int height;

vector<Ball*> balls;

char getSymbol(int x, int y);

}

Definizione del campo

(27)

void Field::add(Ball* b) { balls.push_back(b);

}

void Field::moveAll() {

for (int i = 0; i < balls.size(); ++i) { Ball* ball = balls[i];

ball->move();

} }

Field::~Field() {

for (int i = 0; i < balls.size(); ++i) { Ball* ball = balls[i];

delete ball;

} }

Implementazione del campo

(28)

Il metodo getSymbol è privato

Non è un servizio che l’oggetto offre ad altri Può essere chiamato solo dall’oggetto stesso

I metodi privati servono per decomporre un algoritmo come nell’approccio procedurale

Metodi privati

Michele Tomaiuolo Fondamentidi informatica Oggetti C++

Full text

Oggetti C++

Fondamenti di informatica

Michele Tomaiuolo

tomamic@ce.unipr.it

http://www.ce.unipr.it/people/tomamic

Oggetto

Astrazione per un oggetto fisico o un concetto (in problema, o soluzione) caratterizzato da:

Uno stato interno (memorizzato in campi)

Un insieme di servizi esposti agli altri oggetti (realizzati come metodi)

Una identità

(diversa locazione in memoria)

Fields (state)

Methods

Classi ed oggetti

Nei linguaggi class-based, come Java e C++...

Ogni oggetto ha (almeno) una classe di origine

La classe dà la stessa forma (campi e metodi) a tutti i suoi oggetti... ma i valori nei campi sono distinti

Poi, creazione oggetti e invio messaggi

Istanza della classe X ≡ oggetto di classe X

Ogni istanza ha uno stato e una identità (locazione in memoria) distinti...

Anche rispetto ad altre istanze della stessa classe

Ball: progetto C++

C++: definizione della classe separata dalla

implementazione dei metodi

Definizione fornita agli utenti

Implementazione compilata in libreria

Sorgenti organizzati in 3 file:

ball.h – definizione della classe

ball.cpp – implementazione dei metodi main.cpp – applicazione che usa la classe

Dall'ambiente di sviluppo: Add new → C++ Class

x y

dx

dy getX

getY

move

#ifndef BALL_H

#define BALL_H class Ball { public:

Ball();

Ball(int x0, int y0, int dx0, int dy0);

void move();

int getX();

int getY();

static const int WIDTH = 16;

static const int HEIGHT = 12;

private:

int x; int y;

int dx; int dy;

};

Definizione: ball.h

Ball

Implementazione: ball.cpp

#include "ball.h"

Ball::Ball() {

x = WIDTH/2; y = HEIGHT/2; dx = +1; dy = +1;

}

Ball::Ball(int x0, int y0, int dx0, int dy0) { x = x0; y = y0; dx = dx0; dy = dy0;

}

void Ball::move() {

if ((x + dx < 0) || (x + dx >= WIDTH)) { dx = -dx; } if ((y + dy < 0) || (y + dy >= HEIGHT)) { dy = -dy; } x += dx; y += dy;

}

int Ball::getX() { return x; }

int Ball::getY() { return y; }

#include "ball.h"

/* … */

int main() {

// create a ball: default position and direction Ball ball1;

ball1.move();

ball1.move();

cout << ball1.getX() << ", " << ball1.getY() << endl;

// create another ball Ball ball2(8, 4, +1, -1);

ball2.move();

ball2.move();

cout << ball2.getX() << ", " << ball2.getY() << endl;

return 0;

Applicazione: main.cpp

Costruttore

Metodo speciale per impostare lo stato iniziale

Nessun tipo di ritorno

p = p + 1; // ++i