Pillole di C++

Il C++ in pillole
Corrado Santoro
ARSLAB - Autonomous and Robotic Systems Laboratory
Dipartimento di Matematica e Informatica - Universit`a di Catania, Italy
santoro@dmi.unict.it
L.A.P. 1 Course
Corrado Santoro Il C++ in pillole

C++: Deﬁnizioni e Sintassi Base

Il C++ è ...
l’estensione del C con il supporto della programmazione ad
oggetti.
Ha le seguenti caratteristiche base:
Definizione di classi e oggetti.
Allocazione statica e dinamica degli oggetti.
Ereditarietà singola e multipla.
Ereditarietà virtual e non-virtual.
Overloading degli operatori.
Template (simili ai generics di Java).
Libreria run-time molto ricca (Standard Template Library -
STL).

C++: dichiarazione di classe
✞
class MyClass {
private:
// elenco dei membri (attributi e metodi) privati
protected:
// elenco dei membri (attributi e metodi) protetti
public:
// elenco dei membri (attributi e metodi) pubblici
} ; // <----- RICORDATEVI DEL ";" FINALE!!
✡✝ ✆
Esempio:
✞
class Point {
private:
int x, y;
public:
Point(int ax, int ay); // costruttore
int get_x();
int get_y();
} ;
✡✝ ✆

Modificatori di visibilità
public: il metodo o attributo è visibile ovunque.
private: il metodo o attributo è visibile solo all’interno
della stessa classe (default).
protected: il metodo o attributo è visibile solo all’interno
della stessa classe e delle classi ereditate.

C++: dichiarazione e implementazione
A differenza di Java, in C++ esiste (come in C) una netta separazione
tra dichiarazione di classe e implementazione dei metodi.
La dichiarazione di classe riporta solo l’elenco degli attributi ed il
prototipo dei metodi.
L’ implementazione dei metodi è fatta separatamente riportando la
definizione del metodo e, di seguito, il suo codice.
Il nome effettivo del metodo, specificato nell’implementazione, è
formato dalla stringa nomeclasse::nomemetodo.

C++: dichiarazione e implementazione di classe
✞
class Point {
private:
int x, y;
public:
int get_x();
int get_y();
} ;
Point::Point(int ax, int ay)
{
x = ax; y = ay;
}
int Point::get_x()
{
return x;
}
int Point::get_y()
{
return y;
}
✡✝ ✆

C++: dichiarazione e implementazione di classe
E’ tuttavia possibile implementare un metodo direttamente nella
dichiarazione di classe (Java-style). In tal caso il metodo verr`a
trattato come inline.
✞
class Point {
private:
int x, y;
public:
int get_x() { return x; };
int get_y() { return y; };
} ;
{
x = ax; y = ay;
}
✡✝ ✆

Creazione e uso degli oggetti
✞
class Point {
private:
int x, y;
public:
} ;
{ x = ax; y = ay; }
int main(int argc, char **argv)
{
Point p(4,5); // creazione *statica* oggetto p di classe Point
printf("Point p = %d, %dn", p.get_x(), p.get_y());
}
✡✝ ✆
L’accesso ai metodi/attributi di un oggetto si effettua con la
notazione puntata.
p è definito all’interno della funzione main e pertanto avrà
visibilità e vita solo dentro main.
Appena la funzione terminerà, p sarà distrutto (stessa
semantica delle variabili C).

Un altro esempio
✞
#include <stdio.h>
class Point {
private:
int x, y;
public:
Point add(Point p);
} ;
{ x = ax; y = ay; }
Point Point::add(Point p)
{
Point ret_val(x + p.get_x(), y + p.get_y());
return ret_val;
}
{
Point p1(4,5), p2(10,10);
Point p3 = p1.add(p2);
printf("Risultato = %d, %dn", p3.get_x(), p3.get_y());
}
✡✝ ✆
Compilazione: g++ file.cc -o file ...

Passaggio parametri, puntatori e reference

Semantica del passaggio di oggetti a metodi/funzioni
La semantica di passaggio dei parametri è identica a quella
del C, cioé i parametri (qualunque essi siano) vengono
passati sempre per copia.
Passare un oggetto a un metodo significa pertanto effettuarne
una copia.
✞
...
Point Point::add(Point p)
{
// p riceve *una copia* di p2 e *non lo stesso p2*
return ret_val;
// nella fase di "return", p3 riceve una *copia* di ret_val,
// mentre ret_val viene distrutto alla conclusione del metodo add()
}
{
Point p1(4,5), p2(10,10);
Point p3 = p1.add(p2); // <--- p2 viene *copiato* sulla variabile p del metodo add
}
✡✝ ✆

Reference agli oggetti
Q: E’ possibile avere dei reference, cos`ı come in Java?
A: S`ı!, usando i puntatori e l’allocazione dinamica✞
#include <stdio.h>
class Point {
int x, y; // private per default
public:
Point add(Point * p);
} ;
{ x = ax; y = ay; }
Point Point::add(Point * p)
{
// p punta a p2; p2 e (*p) sono *LO STESSO OGGETTO*
Point ret_val(x + p->get_x(), y + p->get_y());
// dato che p risulta un *puntatore*, uso la notazione "->"
return ret_val;
}
{
Point p1(4,5), p2(10,10);
Point p3 = p1.add(&p2); // <-- passo il *PUNTATORE* a p2
}
✡✝ ✆

Puntatori e reference
In C++ è possibile “nascondere” un puntatore usando una sintassi
che permette di specificare un tipo reference ad oggetto.
Di fatto è un puntatore solo che è nascosto (stessa semantica Java).
✞
class Point {
...
public:
...
Point add(Point & p);
} ;
...
Point Point::add(Point & p)
{
// p e p2 sono *LO STESSO OGGETTO*, il puntatore risulta ‘‘nascosto’’
return ret_val;
}
{
Point p1(4,5), p2(10,10);
Point p3 = p1.add(p2);
}
✡✝ ✆

Allocazione Dinamica

Allocazione dinamica
E’ possibile allocare dinamicamente un oggetto usando
l’operatore new (equivalente al “malloc”) il quale restituisce
un puntatore all’oggetto.
Tuttavia ogni oggetto allocato dinamicamente dovrà
essere esplicitamente distrutto usando l’operatore
delete (no garbage collection).
Ogni oggetto allocato dinamicamente esiste sempre fino
a che non è distrutto esplicitamente da un delete.
Esempio: Point * p = new Point(3,4);

Allocazione dinamica
✞
#include <stdio.h>
class Point {
public:
Point * add(Point * p);
} ;
{ x = ax; y = ay; }
Point * Point::add(Point * p)
{
// alloco il risultato dinamicamente e ne restituisco il puntatore
Point * ret_val = new Point(x + p->get_x(), y + p->get_y());
return ret_val;
}
{
Point p1(4,5), p2(10,10);
Point * p3 = p1.add(&p2);
printf("Risultato = %d, %dn", p3->get_x(), p3->get_y());
delete p3;
}
✡✝ ✆

Allocazione dinamica di array
E’ possibile usare gli operatori “new” e “delete” anche per
allocare dinamicamente/deallocare un array.
Allocazione di un array di tipo T:
T * a = new T[size];
Deallocazione di un array:
delete [] a;
Esempio: int * p = new int[300];

Costruttori e Distruttori

Costruttore e Distruttore
La gestione del ciclo di vita di un oggetto `e demandata al
programmazione che ne controlla sia la creazione che la
distruzione (implicita o esplicita).
Accanto al metodo speciale “costruttore” esiste dunque
anche un metodo speciale denominato distruttore che
viene invocato quando l’oggetto `e cancellato dalla
memoria.
✞
class Point {
public:
˜Point(); // distruttore
Point * add(Point * p);
} ;
Point::˜Point()
{
// .. codice del distruttore
}
✡✝ ✆

Distruttore
L’uso del distruttore `e fondamentale per liberare eventuali
zone di memoria allocate dinamicamente dall’oggetto,
altrimento non verrebbero rilasciate (no garbage collection).
✞
class MyClass {
int * array;
public:
MyClass(int n); // costruttore
˜MyClass(); // distruttore
...
} ;
MyClass::MyClass(int n)
{
array = new int[n];
}
MyClass::˜MyClass()
{
delete [] array;
}
✡✝ ✆

Overloading Operatori

Tutti gli operatori (artimetici, logici, relazionali, array
subscript []) posso essere ridefiniti sulla base del tipo dei
loro argomenti.
Esempio: considerando una classe Complex che
rappresenta un numero complesso, è possibile ridefinire gli
operatori aritmetici in modo da poter scrivere un codice del
tipo:
✞
...
Complex a, b, c, d;
d = a + b * c;
...
✡✝ ✆

Data un’espressione del tipo:
✞
Complex result, lhs, rhs;
result = lhs + rhs;
✡✝ ✆
Il comportamento dell’operatore “+” pu`o essere rideﬁnito in una
funzione o metodo chiamato operator+ con uno dei seguenti
prototipi:
✞
// FUNZIONI
Complex operator+(Complex lhs, Complex rhs);
Complex operator+(Complex &lhs, Complex rhs);
Complex operator+(Complex lhs, Complex &rhs);
Complex operator+(Complex &lhs, Complex &rhs);
✡✝ ✆
✞
// METODI DELLA CLASSE COMPLEX
Complex Complex::operator+(Complex rhs);
Complex Complex::operator+(Complex &rhs);
✡✝ ✆

Overloading Operatori: Esempio
✞
class Complex {
float re, im;
public:
Complex();
Complex(float r, float i);
void set(float r, float i) { re = r; im = i; };
float real() { return re; };
float imag() { return im; };
Complex operator+(Complex & p);
};
Complex::Complex()
{
re = 0; im = 0;
}
Complex::Complex(float r, float i)
{
this->re = r; this->im = i;
}
Complex Complex::operator+(Complex & p)
{
Complex result(re + p.re, im + p.im);
return result;
}
✡✝ ✆

Overloading Operatori: Esempio
✞
class Complex {
float re, im;
public:
Complex();
};
...
Complex Complex::operator+(Complex & p)
{
Complex result(re + p.re, im + p.im);
return result;
}
main()
{
Complex a(1,2), b(3,4);
Complex c = a + b;
printf("Risultato = %f,%fn", c.real(), c.imag());
}
✡✝ ✆

Overloading Operatori: Esempio 2
✞
class Complex {
float re, im;
public:
Complex();
};
...
Complex operator+(Complex & lhs, Complex & rhs)
{
Complex result(lhs.real() + rhs.real(), lhs.imag() + rhs.imag());
return result;
}
main()
{
Complex a(1,2), b(3,4);
Complex c = a + b;
printf("Risultato = %f,%fn", c.real(), c.imag());
}
✡✝ ✆

Overloading Operatori e Stream
L’overloading degli operatori permette d’uso di una sintassi
“elegante” quando occorre accedere ai file.
I file in C++ (cos`ı come in Java) sono virtualizzati tramite
oggetti di tipo stream.
Poichà la console è essa stessa un file, essa è
virtualizzata tramite due oggetti:
cout, di tipo ostream (equivalente alla printf)
cin, di tipo istream (equivalente alla scanf)
Essi sono definiti nell’header iostream
Utilizzano gli operatori “>>” e “<<”

Stream e Cout: Esempio
✞
#include <iostream> // senza il .h, gli header file C++ non lo hanno
using namespace std;
// cout e cin sono definiti nel "namespace" std
// Lo "using" serve a impostare un prefisso di namespace,
// altrimenti occorrerebbe esplicitarlo
main()
{
cout << "Hello worldn";
}
✡✝ ✆
✞
#include <iostream> // senza il .h, gli header file C++ non lo hanno
// cout e cin sono definiti nel "namespace" std
// Lo "using" serve a impostare un prefisso di namespace,
// altrimenti occorrerebbe esplicitarlo
main()
{
int a, b;
cout << "Inserisci due valori:";
cin >> a;
cin >> b;
cout << "Somma = " << (a + b) << "n";
}
✡✝ ✆

Polimorﬁsmo

Polimorfismo
In C++ ogni metodo o funzione può avere diverse forme
(implementazioni) che differiscono a seconda dei tipi e del numero di
parametri forniti.
✞
class Complex {
float re, im;
public:
Complex();
void set(Complex &c) { re = c.real(); im = c.imag(); };
};
✡✝ ✆
Nell’esempio il metodo set è polimorfico in quanto sono presenti due
versioni:
La prima con due parametri float
La seconda con un solo parametro Complex

Polimorfismo, overloading operatori e cout
Cosa accade con una istruzione del genere?
✞
float res = 10.5;
cout << "Risultato = " << res << "n";
✡✝ ✆
1. L’operatore << è left-associativo, quindi l’espressione equivale a:
✞
float res = 10.5;
( ( (cout << "Risultato = ") << res) << "n");
✡✝ ✆
2. Valutazione della prima parentesi, viene cercata la funzione
seguente:
✞
ostream & operator<<(ostream & out, char * s)
{
printf("%s", s);
return out;
}
✡✝ ✆
3. “Risultato = ” è stampato a schermo e l’espressione diventa:
✞
float res = 10.5;
( ( cout << res) << "n");
✡✝ ✆

Polimorﬁsmo, overloading operatori e cout
✞
float res = 10.5;
( ( cout << res) << "n");
✡✝ ✆
4. Valutazione della successiva parentesi, viene cercata la funzione
seguente:
✞
ostream & operator<<(ostream & out, float f)
{
printf("%f", f);
return out;
}
✡✝ ✆
5. “10.5” `e stampato a schermo e l’espressione diventa:
✞
( cout << "n");
✡✝ ✆
6. Valutazione dell’ultima, viene cercata nuovamente la funzione
seguente:
✞
ostream & operator<<(ostream & out, char * s);
✡✝ ✆
7. Il carattere di a-capo viene stampato sullo schermo.

Ereditariet`a

Ereditariet`a: Sintassi
class newClass : visibility baseClass { ... } ;
✞
class InheritedClass : private BaseClass {
// ....
};
class InheritedClass : protected BaseClass {
// ....
};
class InheritedClass : public BaseClass {
// ....
};
✡✝ ✆
private: i membri public di BaseClass diventano private in
InheritedClass.
protected: i membri public di BaseClass diventano protected in
InheritedClass, i protected diventano private.
public: nessuna modiﬁca.

Esempio sull’ereditariet`a
Una classe Rectangle e una classe ereditata Square che
specializza la classe base:
✞
class Rectangle {
float width, height;
public:
Rectangle(float w, float h);
float area() { return width * height; } ;
} ;
class Square : public Rectangle {
public:
Square(float side);
};
Rectangle::Rectangle(float w, float h)
{
width = w;
height = h;
}
✡✝ ✆

Esempio sull’ereditariet`a: sintassi dei costruttori
Ogni classe ereditata, nel suo costruttore, deve chiamare il
costruttore padre come prima istruzione:
✞
class Rectangle {
public:
} ;
public:
Square(float side);
};
{
width = w;
height = h;
}
Square::Square(float side) : Rectangle(side, side) // invocazione del costruttore del padre
{
// niente da fare qua!
}
✡✝ ✆

Esempio sull’ereditariet`a
✞
#include <iostream>
class Rectangle {
public:
} ;
public:
Square(float side);
};
{ width = w; height = h; }
{ }
{
Rectangle r(10,20);
Square q(50);
cout << "Area rettangolo = " << r.area() << "n";
cout << "Area quadrato = " << q.area() << "n";
}
✡✝ ✆

Usiamo l’allocazione dinamica
✞
#include <iostream>
class Rectangle {
public:
} ;
public:
Square(float side);
};
{ width = w; height = h; }
{ }
{
Rectangle * r = new Rectangle(10,20);
Square * q = new Square(50);
cout << "Area rettangolo = " << r->area() << "n";
cout << "Area quadrato = " << q->area() << "n";
}
✡✝ ✆

Polimorfismo dei puntatori
✞
...
class Square : public Rectangle { ... };
...
void print_area(Rectangle * obj)
{
cout << "Area = " << obj->area() << "n";
}
{
print_area(r);
print_area(q);
}
✡✝ ✆
Ciò è possibile in quanto il tipo di q è polimorfico:
“Square *” per definizione, e
“Rectangle *” poiché Square è sottoclasse di
Rectangle.

Virtual vs. non-virtual inheritance
✞
...
class Rectangle {
public:
void show_area() { cout << "Area rettangolo = " << area() << "n"; };
} ;
public:
Square(float side);
void show_area() { cout << "Area quadrato = " << area() << "n"; };
};
...
{
obj->show_area();
}
{
print_area(r);
print_area(q);
}
✡✝ ✆
Cosa ci aspettiamo che stampi questo programma?

✞
...
class Rectangle {
public:
void show_area() { cout << "Area rettangolo = " << area() << "n"; };
} ;
public:
Square(float side);
};
...
{
obj->show_area();
}
{
print_area(r);
print_area(q);
}
✡✝ ✆
✞
Area rettangolo = 200
✡✝ ✆

Non-virtual inheritance: Data una classe C, un metodo m e un
oggetto a di tipo C * ma proveniente da un tipo D *, dove D è
sottoclasse di C, la scrittura a->m() esegue sempre il codice
del metodo definito in C. (Comportamento di default del C++,
non presente in Java)
Virtual inheritance: Data una classe C, un metodo m e un
oggetto a di tipo C * ma proveniente da un tipo D *, dove D è
sottoclasse di C, la scrittura a->m() esegue sempre il codice
del metodo definito in D. (Comportamento da esplicitare in
C++ tramite la keyword virtual, modello di default in Java)

✞
...
class Rectangle {
public:
virtual void show_area() { cout << "Area rettangolo = " << area() << "n"; };
} ;
public:
Square(float side);
};
...
{
obj->show_area();
}
{
print_area(r);
print_area(q);
}
✡✝ ✆
✞
Area quadrato = 2500
✡✝ ✆

Pillole di C++

More Related Content

What's hot

Viewers also liked

Similar to Pillole di C++

Pillole di C++