2. C++
•Le classi
•Proprietà e metodi
•Gli oggetti
•L’ereditarietà
•Incapsulamento
•Overloading
•Polimorfismo
•Persistenza
•Simula
• Smalltalk
• C++
• Visual Basic
• Java
Linguaggio OO
Estende le caratteristiche del C
fornendo i meccanismi per
l'astrazione dei dati e la
programmazione orientata agli
oggetti.
3. C++ Inoltre...
• E’ un linguaggio “all purpose”;
• Mantiene una compatibilità “quasi completa” con il C;
• Porting agevole delle applicazioni;
Svantaggi:
• Maggiore sforzo nella progettazione delle applicazioni;
• Complessità del linguaggio
4. C++ Hello World
#include "stdafx.h"
#include < iostream.h >
int main(int argc, char* argv[])
{
cout << "Hello World !!!" << endl;
return 0;
}
•“” : stessa directory, /I (opzione di compilazione) , INCLUDE;
•<>: /I, INCLUDE;
5. C++ Il Linguaggio
void Func() { ...
// questo è un commento su un’unica riga
int a = 5; /* questo e` un commento
diviso su piu` righe */
a = 4 /* commento */ + 5;
... }
Commenti
Identificatori
Gli identificatori sono simboli definiti dal
programmatore per riferirsi a cinque diverse categorie
di oggetti:
•Variabili;
•Costanti simboliche;
•Etichette;
•Tipi definiti dal programmatore;
•Funzioni.
6. C++
Parole riservate:
Il Linguaggio
Sono inoltre considerate parole chiave tutte quelle che iniziano con un doppio underscore
__; esse sono riservate per le implementazioni del linguaggio e per le librerie standard, e il
loro uso da parte del programmatore dovrebbe essere evitato in quanto non sono portabili.
7. C++ Il Linguaggio
Tipi primitivi:
Un tipo e` una coppia <V, O>, dove V e` un insieme di valori e O e` un insieme
di operazione per la creazione e la manipolazione di elementi di V. I quattro tipi
fondamentali del C++:
•char :utilizzato per rappresentare piccoli interi e caratteri;
•int :per numeri interi in un intervallo più ampio di char;
•float :numeri a virgola mobile a singola precisione;
•double :numeri a virgola mobile a doppia precisione;
8. C++ Il Linguaggio: Tipi Primitivi
Ai tipi fondamentali e` possibile applicare i qualificatori
signed, unsigned, short e long per selezionare differenti
intervalli di valori:
char
short int
int
long int
signed char
signed short int
signed int
signed long int
unsigned char
unsigned short int
unsigned int
unsigned long int
float
double
long double
•Esercitazione sulla
dimensione(in byte) dei
vari tipi (sizeof operator).
9. C++ Il Linguaggio:
Dichiarazione di Variabili
short int s1,s2,s3=5;
int s2=5555;
char a=‘c’;
char c3=c1+1;
All'interno delle espressioni e` possibile inserire direttamente dei valori,
questi valori sono detti costanti letterali: ‘a’ // carattere “abc” // stringa
20 // intero in base 10
024 // 20 in base 8
0x14 // 20 in base 16
12ul // forza unsigned long
12l // forza long
12u // forza unsigned
.0 // 0 in virgola mobile
110E+4 // equivalente a 110 * 10000 (10 elevato a 4)
.14e-2 // 0.0014
-3.5e+3 // -3500.0
3.5f // forza float
3.4L // forza long double
10. C++ Il Linguaggio:
Caratteri Speciali
Nome ASCII Carattere
A capo NL n
Tab orizzontale HT t
Tab verticale VT v
Spazio indietro BS b
Ritorno carrello CR r
Form feed FF f
Campanello BEL a
Slash
Apice ‘ ’
11. C++ Il Linguaggio: Operatori
Gli operatori sono raggruppati per tipologia e ordinati per precedenza di valutazione
12. C++
Il Linguaggio: Operatori
•Gli operatori unari e quelli di assegnamento sono associativi
a destra, gli altri a sinistra;
•L'operatore ? : e` l'unico operatore ternario:
s1>0?y=x+1:y=x-1; // <Cond> ? <Expr2> :<Expr3>
• = (assegnamento):un programma C++ e` sostanzialmente
una sequenza di assegnamenti di valori a variabili del tipo:
lvalue=rvalue;
Il termine lvalue indica una qualsiasi espressione che riferisca
ad una regione di memoria (in generale un identificatore di
variabile), mentre un rvalue e` una qualsiasi espressione la
cui valutazione produca un valore.
13. C++ Il Linguaggio:Operatori
Pluto = Pippo = 5;
equivale a
Pluto = (Pippo = 5);
Concatenazione di operatori binari:
Pippo += 5;// equivale a Pippo = Pippo + 5;
Pippo -= 10;// equivale a Pippo = Pippo -
10;
Pippo *= 3;// equivale a Pippo = Pippo * 3;
Operatori di autoincremento e autodecremento:
Pippo++; // Pippo += 1;
++Pippo; // Pippo += 1;
Pippo--; // Pippo -= 1;
--Pippo; // Pippo -= 1;
Pluto = ++Pippo;// equivale a:Pippo++;Pluto = Pippo;
Pluto = Pippo++;// equivale a:Pluto = Pippo;Pippo++;
14. C++ Il Linguaggio:Input e Output
int main(int argc, char* argv[])
{
double valore;
cout << "Digita un numero:" ;
cin >> valore;
cout << "Hai battuto:" << valore << endl;
return 0;
}
extern ostream cout;
extern istream cin;
15. C++ Il Linguaggio:Controllo del flusso
if ( <Condizione> ) <Blocco1> ;
else <Blocco2> ;
IF-ELSE
while ( <Condizione> ) <Blocco> ; WHILE
do <Blocco> while ( <Condizione> ) ; DO-WHILE
for ( <Inizializzazione> ; <Condizione> ; <Iterazione> )
<Blocco>
FOR
16. C++ Il Linguaggio:Controllo del flusso
Fattoriale = 1;
while (1) { // all'infinito...
if (InteroPositivo > 1) {
Fattoriale *=Interopositivo--;
continue;
}
break; // se eseguita allora InteroPositivo <= 1
// continue provoca un salto in questo punto
}
BREAK & CONTINUE
switch ( <Espressione> )
{
case <Valore1>: <Blocco> ; /* ... */
case <ValoreN> : <Blocco> ;
default : <Blocco> ;
}
SWITCH
17. C++ Il Linguaggio:Controllo del flusso
<Etichetta> : <Istruzione>
...
goto <Etichetta>
GOTO
COSTANTI
const double pi=3.1415926;
18. C++ Il Linguaggio: Scope e lifetime
{ ... int X = 5;
{ // X e` visibile anche in questo blocco ...
}
…
}
{ ...
int X = 5;
{
char X = 'a'; // ora e` visibile char X …
}
// qui e` visibile int X
…
}
19. C++ Il Linguaggio: Scope e lifetime
int X = 4; // dichiarazione esterna ad ogni blocco
void main()
{
}
void funz()
{
int x = 5; // x e` creata e distrutta ogni volta
static int c = 3; /* ... */
}
La variabile c è creata la prima volta
che si esegue la funzione e distrutta
alla fine del programma.
20. C++ Il Linguaggio: Array
< Tipo > < Identificatore >[ < NumeroElementi > ];
int Pippo[10];
long double Qui[3][4];
int SuperPippo[12][16][20];
int Pippo[5] = { 10, -5, 6, 110, -96 };
short Pluto[2][4] = { 4, 7, 1, 4, 0, 3, 5, 9 );
float Minni[ ] = { 1.1, 3.5, 10.5 };
long Manetta[ ][3] = { 5, -7, 2, 1, 0, 5 };
char Topolino[ ] = "investigatore" ; // ‘0’
Il Tipo può essere anche un tipo
definito dall’utente (astratto).
Topolino[4] = 't'; // assegna 't' al quinto elemento
21. C++ Il Linguaggio: Strutture
struct < NomeTipo >
{
< Tipo > < NomeCampo > ;
...
< Tipo > < NomeCampo > ;
};
struct Persona
{
char Nome[20];
unsigned short Eta;
char CodiceFiscale[16+1];
};
Persona Pippo = { "Pippo", 40, "PPP718F444E18DR0" };
Pippo.Eta = 41;
Persona Pluto=Pippo;
22. C++ Il Linguaggio: Union
union TipoUnione {
unsigned Intero;
char Lettera;
char
Stringa[500]; };
Mentre in una struttura i vari campi vengono memorizzati in indirizzi diversi e
non si sovrappongono mai, in una unione invece tutti i campi vengono
memorizzati a partire dallo stesso indirizzo. Cio` vuol dire che, mentre la
quantita` di memoria occupata da una struttura e` data dalla somma delle
quantita` di memoria utilizzata dalle singole componenti, la quantita` di
memoria utilizzata da una unione e` data da quella della componente piu`
grande (Stringa in questo caso). Dato che le componenti si sovrappongono,
assegnare un valore ad una di esse vuol dire distruggere i valori memorizzati
accedendo all'unione tramite una qualsiasi altra componente.
23. C++ Il Linguaggio:Enumerazioni
enum < NomeTipo >
{
< Identificatore >,
/* ... */
< Identificatore >
};
enum Elemento
{Idrogeno, Elio,
Carbonio, Ossigeno };
enum Elemento
Elemento Atomo = Idrogeno;
int Numero = Carbonio; // Ok!
Atomo = 3; // Errore!
{ Idrogeno = 2,
Elio, Carbonio = Idrogeno - 10,
Ferro = Elio + 7, Ossigeno = 2 };
Non esiste l’operatore di conversione da int
a Elemento.
24. C++ Il Linguaggio:Typedef
Permette di dichiarare un alias per un altro tipo (non un
nuovo tipo):
typedef < Tipo > < Alias > ;
typedef unsigned short int PiccoloIntero;
typedef long double ArrayDiReali[20];
typedef struct { long double ParteReale;
long double ParteImmaginaria;} Complesso;
25. C++ Il Linguaggio:Le funzioni
int Sum(int a, int b); Dichiarazione di una funzione (.h)
int Sum(int x, int y)
{ return x+y; }
Implementazione di una
funzione (.cc,.cxx,.cpp)
int Sum (int a = 0, int b = 0);
int Sum (const int a ,int b);
Passaggio di parametri
per riferimento:
void scambia(int & a,int & b);
inline void scambia(int &x,int &y)
{
...
}
funzioni inline
26. C++ Il Linguaggio: Overloading di
Funzioni
int Sum(int a, int b);
float Sum(float a, int b);
float Sum(int a, float b);
Il compilatore si basa univocamente sui tipi di parametri
in input, quindi non si può avere:
void Foo(int a, float f);
int Foo(int a, float f);
27. C++ Il Linguaggio: I puntatori
I puntatori possono essere pensati come maniglie da applicare alle porte delle
celle di memoria per poter accedere al loro contenuto sia in lettura che in
scrittura, nella pratica una variabile di tipo puntatore contiene l'indirizzo di una
locazione di memoria.
Vediamo alcune esempi di dichiarazione di puntatori:
short * p1;
Persona * p2;
double * * p3;
int UnIntero = 5;
int * PuntatoreAInt =
&UnIntero;
Puntatore = 0;//non punta a
nulla (NULL)
void * PuntatoreGenerico;
I puntatori void possono essere
inizializzati come un qualsiasi altro
puntatore tipizzato, e a differenza di
questi ultimi possono puntare a
qualsiasi oggetto senza riguardo al tipo
o al fatto che siano costanti, variabili o
funzioni; tuttavia non e` possibile
eseguire sui puntatori void alcune
operazioni definite sui puntatori
tipizzati.
28. C++ Il Linguaggio: I puntatori
int y=5;
int *x=0; //NULL
x=&y;
* = operatore che deferenzia
un puntatore (non è applicato
solo in fase di dichiarazione).
Persona Pippo;
Persona * Puntatore = &Pippo;
Puntatore -> Eta = 40; -> = deferenzia e
automaticamente seleziona il
campo Eta.
Atri operatori: +,-,>,<,>=,<=,==,!=
29. C++ Il Linguaggio: Puntatori vs
Array
Un array (inteso come l’identificatore utilizzato per
“referenziarlo”) non è altro che il puntatore al primo
elemento dell’array.
int a[3]={1,2,3};
int *p=0;
p=&a[0];
if (p==a)
cout << "Vera" << endl;
30. C++ Il Linguaggio: Reference
I reference (riferimenti) sono un costrutto a meta` tra puntatori e
variabili: come i puntatori essi sono contenitori di indirizzi, ma non e`
necessario dereferenziarli per accedere all'oggetto puntato (si usano
come se fossero variabili).
int Var = 5;
float f = 0.5;
int * IntPtr = &Var;
int & IntRef = Var; // nei reference non e` necessario
float & FloatRef = f; // usare & a destra di =
int * IntPtr = new int(5);
int & IntRef = *IntPtr;
31. C++ Il Linguaggio: Reference
int *p;
p=new int[2];
*p=1;
*(p+1)=2;
int &r=*p;
for (int i=0;i<2;i++)
cout << r+i << endl;
//delete p;
delete &r;
double & Esempio(float p1,
float p2);
double * Esempio(float p1,
float p2);
Una funzione può restituire sia un
puntatore che un reference.
int &r=*new int[2];
32. C++ Il Linguaggio: Puntatori vs
Reference
int x=5;
int *px=&x;
int &z=somma(px,x);
int &somma(int *x,int y)
{ int *z=new int;
*z=*x+y;
return *z;
}
33. C++ Il Linguaggio: Linkage
In C++ l'unita` di compilazione e` il file. Un programma puo` consistere
di piu` file che vengono compilati separatamente e poi linkati (collegati)
insieme per ottenere un file eseguibile. Quest'ultima operazione e` svolta
dal linker e possiamo pensare al concetto di linkage sostanzialmente
come a una sorta di scope dal punto di vista del linker.
// File a.cpp
int a = 5;
// File b.cpp
extern int a; int GetVar()
{ return a; }
// File a.cpp
int a = 5;
int f(int c)
{ return a+c; }
// File b.cpp
extern int f(int);
int GetVar()
{ return f(5); }
34. C++ Il Linguaggio: Linkage
// Contenuto file C++
extern "C" int CFunc(char *);
extern "C" char * CFunc2(int);
In questo modo attraverso la extern è possibile linkare un
modulo C ad un modulo C++.
35. C++ Il Linguaggio: Header
// Esempio.h
enum Color { Red, Green, Blue };
struct Point {
float X;
float Y;
};
const int Max = 1000;
inline int Sum(int x, int y) {
return x + y;
}
L'uso dei file header e` molto utile
quando si vuole partizionare un
programma in piu` moduli.
Tuttavia la potenza dei file header
si esprime meglio quando si vuole
realizzare (o utilizzare) una
libreria di funzioni.
// Modulo1.cpp
#include "Esempio.h"
36. C++ OOP
La programmazione orientata agli oggetti (OOP) impone una nuova visione di
concetti quali "Tipo di dato" e "Istanze di tipo". Sostanzialmente mentre gli altri
paradigmi di programmazione vedono le istanze di un tipo di dato come una
entita` passiva (solo dati), nella programmazione a oggetti invece tali istanze
diventano a tutti gli effetti entita` (oggetti) attive.
L'idea e` che non bisogna piu` manipolare direttamente i valori di una struttura
(intesa come generico contenitore di valori), meglio lasciare che sia la struttura
stessa a manipolarsi e a compiere le operazioni.
Un’entità attiva viene dichiarata tramite una dichiarazione di classe.
37. C++ Le Classi
class <ClassName>
{
public: <membri pubblici>
protected: <membri protetti>
private: <membri privati> };
Dichiarazione di una classe
•Se la dichiarazione di una proprietà non è inserita in
alcuna sezione è private per default;
•I metodi possono essere implementati sia nella
dichiarazione della classe che in un secondo momento;
38. C++ Le Classi
Esempio: #include <iostream.h>
class MyClass
{
private:
void MioMetodoPrivate(const int i)
{
cout << "MioMetodoPrivate" << endl;
}
public:
void MioMetodoPublic(const int i);
protected:
};
h
#include "stdafx.h"
#include "MyClass.h"
void MyClass::MioMetodoPublic(const int x)
{
cout << "MioMetodoPublic" << endl;
}
cpp
this
39. C++ Le Classi
Costruttori: Metodo richiamato alla creazione dell’istanza
di una classe. E’ utilizzato per rendere consistente lo stato
dell’istanza.
public:
...
MyClass();
MyClass(const int i);
MyClass(MyClass& x) : M1(x.M1), M2(x.M2) {...} //copia
MyClass(int a, int b) : M1(a), M2(b) {...} // lista
// inizializzaz.ne
...
MyClass c; // !!! La classe e instanziata
MyClass c(3);
MyClass c(x); MyClass &r=*new MyClass(x);
MyClass *p=new MyClass(x);
40. C++ Le Classi
Distruttore:Poiche` ogni oggetto ha una propria durata
(lifetime) e` necessario disporre anche di un metodo che
permetta una corretta distruzione dell'oggetto stesso, un
distruttore.
~MyClass();
...
MyClass::~MyClass()
{
...
}
E’ un metodo che non ricerve parametri e non ritorna alcun
tipo (neanche void).
41. C++ Le Classi
Membri Static : Membri propri della classe (non dell’istanza). Non è possibile
inizializzarli tramite lista .
static int num;
static void MetodoStatic();
int MyClass::num = 0;
// prima di essere utilizzata
…
cout << MyClass::num << endl;
MyClass::MetodoStatic();
Membri Const : Esso viene allocato per ogni istanza come un normale attributo,
tuttavia il valore che esso assume per ogni istanza viene stabilito una volta per
tutte all'atto della creazione dell'istanza stessa e non potra` mai cambiare durante
la vita dell'oggetto. E’ obbligatoria l’inizializzazione tramite lista.
int GetConstMember() const { return ConstMember; }
La funzione si impegna a non accedere in scrittura ai membri della classe.
42. C++ Le Classi
Vere costanti nelle classi: class Ok { public: /* ... */
private: enum { Size = 20 };
char String[Size]; };
Membri Volatile:
Il C++ e` un linguaggio adatto a qualsiasi tipo di applicazione, in particolare a
quelle che per loro natura si devono interfacciare direttamente all'hardware.
Una prova in tal proposito e` fornita dalla keyword volatile che posta davanti
ad un identificatore di variabile comunica al compilatore che quella variabile
puo` cambiare valore in modo asincrono rispetto al sistema:
volatile int Var;
In questo caso il compilatore non ottimizza l’accesso alla risorsa.
43. C++ Le Classi
Funzioni Friend: permette che una funzione non membro
possa accedere direttamente ai membri (attributi e/o metodi)
privati di una classe.
friend ostream& operator<<(ostream& o, MyClass& Obj);
friend void FriendMethod(MyClass &x);
...
ostream& operator<<(ostream& o, MyClass& Obj)
{ o << Obj.F1 << ' ' << Obj.F2 << ' ' << Obj.C; return o;}
class MyClass {
/* ... */
friend class AnotherClass; };
Il modificatore friend può
essere applicato anche ad una
classe intera.
44. C++ Le Classi:
Ereditarietà
Ereditarietà: Il meccanismo dell'ereditarieta` e` per molti aspetti
simile a quello della composizione quando si vuole modellare una
relazione di tipo Is-a. L'idea e` quella di dire al compilatore che una
nuova classe (detta classe derivata) e` ottenuta da una preesistente
(detta classe base) "copiando" il codice di quest'ultima nella classe
derivata e modificandolo (eventualmente) con nuove definizioni.
class Person {
public: Person(); ~Person();
void PrintData(); /* ... */
private: char * Name;
unsigned int Age; /* ... */ };
class Student : Person
{
public:
Student(); ~Student(); /* ... */
private: unsigned int IdCode; /* ... */
};
45. C++ Le Classi:
Ereditarietà
•La classe derivata puo` accedere ai membri protetti e pubblici della
classe base;
•E’ possobile ridefinire un metodo ereditato dalla classe base:
void Student::PrintData()
{ Person::PrintData();
cout << "Matricola: " << IdCode;
}
•Costruttori per classi derivate:
Student::Student()
{ Person(/* ... */);
/* ... */ }
Student::Student() : Person(/* ... */) {
/* ... */
}
Quando parte il costruttore l’stanza è già stata creata.
46. C++ Le Classi:
Ereditarietà
Per default l'ereditarieta` e` privata, tutti i membri ereditati diventano
cioe` membri privati della classe derivata e non sono quindi parte della
sua interfaccia.
In alternativa:
•Con l'ereditarieta` pubblica i membri ereditati mantengono lo stesso grado di
protezione che avevano nella classe da cui si eredita (classe base immediata): i
membri public rimangono public e quelli protected continuano ad essere
protected;
•Con l'ereditarieta` protetta i membri public della classe base divengono
membri protected della classe derivata; quelli protected rimangono tali.
class < DerivedClassName > : [< Qualifier >] < BaseClassName >
{ /* ... */ };
47. C++ Le Classi:
Ereditarietà
Il C++ supporta, a differenza di molti altri linguaggi,
l’eredità multipla:
class iostream : public istream, public ostream
{ /* ... */ };
L’eredità multipla talvolta può generare ambiguità che
possono essere risolti con i risolutori di scope:
BaseClass1::Member = 10;
48. C++ Le Classi:
Classe 4
Classe 2
Classe 1
Classe 3
Classe 1
Ereditarietà
In questo caso la Classe 2 e la Classe 3
dovranno ereditare in maniera virtuale
(virtual) da Classe 1. In questo modo il
compilatore non si limita solo a copiare
la classe base, ma crea un puntatore ad
un istanza di tale classe. Nel caso in cui
una classe eredita più volte da un classe
base virtuale, i puntatori creati
punteranno alla stessa istanza della
classe base.
Classi Virtuali
class Student : virtual private Person
{}
49. C++ Le Classi: Funzioni Virtuali
T * Ptr = 0;
Ptr = new Td; // Td derivata da T ed entrambi hanno un metodo Paint()
Ptr -> Paint();// Richiama il metodo di T !!!
Le funzioni virtuali fanno in modo che il corretto tipo dell'oggetto
puntato sia automaticamente determinato al momento della chiamata
della funzione e rinviano il linking di tale funzione a run-time.
in T
virtual void Paint();
void T::Paint()
{ // non occorre virtual
/* ... */ }
in Td
virtual void Paint();
void Paint();
Per avere una chiamata risolvibile staticamente:
pT->T::Paint();
50. C++ Classi Astratte
I meccanismi dell'ereditarieta` e delle funzioni virtuali possono essere
combinati per realizzare delle classi il cui unico scopo e` quello di
stabilire una interfaccia comune a tutta una gerarchia di classi:
class TShape {
public:
virtual void Paint() = 0; // Funzioni virtuali pure
virtual void Erase() = 0;// Non sono implementate
/* ... */
};
Una classe che possiede funzioni virtuali pure e detta classe astratta
(o interfaccia) e non e` possibile istanziarla; essa puo` essere
utilizzata unicamente per derivare nuove classi forzandole a fornire
determinati metodi (quelli corrispondenti alle funzioni virtuali pure).
51. C++ Operatori
•Non e` possibile definire nuovi operatori, si puo` solamente
eseguire l'overloading di uno per cui esiste gia` un simbolo nel
linguaggio;
•Non e` possibile modificare la precedenza di un operatore e non
e` possibile modificarne l'arieta` o l'associativita`;
•Non e` concessa la possibilita` di eseguire l'overloading
dell'operatore ternario ? :;
•E` possibile ridefinire un operatore sia come funzione globale
che come funzione membro, i seguenti operatori devono tuttavia
essere sempre funzioni membro non statiche: operatore di
assegnamento ( = ), operatore di sottoscrizione ( [ ] ) e operatore
->.
52. C++ Operatori
< ReturnType > operator@( < ArgumentList > )
{ < Body > }
ReturnType e` il tipo restituito (non ci sono restrizioni); @
indica un qualsiasi simbolo di operatore valido;
ArgumentList e` la lista di parametri (tipo e nome) che
l'operatore riceve, i parametri sono due per un operatore
binario (il primo e` quello che compare a sinistra
dell'operatore quando esso viene applicato) mentre e` uno
solo per un operatore unario. Infine Body e` la sequenza di
istruzioni che costituiscono il corpo dell'operatore.
53. C++ Operatori
struct Complex
{ float Re;
float Im; };
Operatore come funzione globale
Complex operator+(const Complex & A, const Complex & B)
{
Complex Result;
Result.Re = A.Re + B.Re;
Result.Im = A.Im + B.Im; return Result;
}
54. C++ Operatori
Operatore come membro di una classe
class Complex {
public:
Complex(float re, float im);
Complex operator-() const; // - unario
Complex operator+(const Complex & B) const;
const Complex & operator=(const Complex & B);
private:
float Re; float Im;
};
Complex::Complex(float re, float im = 0.0) { Re = re; Im = im; };
Complex Complex::operator-() const { return Complex(-Re, -Im); }
Complex Complex::operator+(const Complex & B) const
{ return Complex(Re+B.Re, Im+B.Im);}
const Complex & Complex::operator=(const Complex & B)
{ Re = B.Re; Im = B.Im; return *this; }
55. C++ Operatori
Ecco alcuni esempi di applicazione dei precedenti operatori
e la loro rispettiva traduzione in chiamate di funzioni (A, B e
C sono variabili di tipo Complex):
B = -A; // analogo a B.operator=(A.operator-());
C = A+B; // analogo a C.operator=(A.operator+(B));
C = A+(-B); // analogo a C.operator=(A.operator+(B.operator-()))
56. C++ Operatori
L'operatore di sottoscrizione
class TArray {
public: ...
int operator[](unsigned int Index);
private: int * Array;
unsigned int ArraySize;
};
Anche gli operatori new e
delete sono ridefinibili
int TArray::operator[](unsigned int Index)
{ if (Index<ArraySize) return Array[Index];
else /* Errore */ }
57. C++ Conversioni di tipo
Si intende una operazione volta a trasformare un valore di
un certo tipo in un altro valore di altro tipo. Esistono
conversioni implicite (decise dal compilatore e dette anche
coercizioni) ed esplicite decise dal programmatore.
int i = 5;
float f = 0.0;
double d = 1.0;
d = f + i;
d = (double)f + (double)i;
58. C++ Conversioni di tipo
Non sempre una conversione di tipo preserva il valore: ad esempio nella
conversione da float a int in generale si riscontra una perdita di precisione. Da
questo punto di vista si puo` distinguere tra conversione di tipo con perdita di
informazione e conversione di tipo senza perdita di informazione. In
particolare in quest'ultimo caso si parla di conversioni triviali e promozione di
tipo. Le conversioni triviali sono:
59. C++ Classi Template
template < class T >
Questa semplice dichiarazione (che non deve essere seguita da ";")
dice al compilatore che la successiva dichiarazione (o definizione)
utilizzera` un generico tipo T che sara` noto solo quando tale codice
verra` effettivamente utilizzato.
template < class T >
class TVector {
public:
Utilizzo
TVector(int Size);
~TVector();
T & operator[](int Index);
private:
T * Data;
int ArraySize; };
TVector< int > IntArray(30);
TVector< TMyClass > MyArray(100);
60. C++ Classi Template
template < class T >
TVector< T >::TVector(int Size) {
ArraySize = Size;
Data = Size? new T(Size) : 0;
}
template < class T >
TVector< T >::~TVector() {
if (Data) delete Data;
}
template < class T >
T & TVector< T >::operator[] (int Index) {
if (!ArraySize || (Index > ArraySize))
/* Segnalazione errore */
else return Data[Index];
}
Se in un metodo di una
classe template viene
utilizzato un operatore,
questo implica che la classe
attraverso il quale il
template è tipizzato deve
aver definito tale operatore.
61. C++ Funzioni Template
template < class T > T & min(T & A, T & B)
{ return (A < B)? A : B; }
TMyClass D(/* ... */);
TMyClass E(/* ... */);
TMyClass F = min(D, E);
Utilizzo
62. C++ Classi Template
Un template puo` avere un qualsiasi numero di parametri e sebbene nella
definizione il generico parametro sia indicato con la notazione class T (es.
template <class T>) non e` necessario che all'atto dell'istanzazione esso sia
sostituito da un identificatore di classe, puo` essere anche utilizzato un tipo
primitivo o uno ottenuto tramite struct, enum, union o typedef. O ancora:
template < class T, int Size >
class TVector { public:
T & operator[](int Index);
private: T Data[Size]; };
template < class T, int Size > T & TVector< T, Size >::operator[] (int Index)
{ if (Index > Size) /* Segnalazione errore */ else return Data[Index]; }
TVector< char *, 20 > A;
TVector< TMyClass, 30 > B;
63. C++ Classi Template
Ereditarietà
template< class T >
class Base { /* ... */ };
template< class T >
class Derived : public Base< T >
{ /* ... */ };
65. C++
Allocazione e
deallocazione di una
matrice bidimensionale
#include <iostream.h> // cout, cin, cerr ...
#include <stdlib.h> // ANSI Compatibilità, malloc...
#include <string.h> // strcpy...
void main(int argc, char* argv[])
{
long **mat; // Dichiaro un puntatore ad un puntatore di long;
long altezza=atol(argv[1]);
long larghezza=atol(argv[2]);
long i,j;
if (argc!=3)
{
cout << "Errore nel passaggio dei Parametri" << endl;
return;
}
66. C++
Allocazione e
deallocazione di una
matrice bidimensionale
// Allocazione matrice
// Alloco puntatori entry alle righe della matrice
mat=new long *[altezza];
// Alloco le righe della matrice
for (i=0;i<altezza;i++)
mat[i]=new long[larghezza];
// Carico la matrice
for (i=0;i<altezza;i++)
for (j=0;j<larghezza;j++)
mat[i][j]=i+j;
// Stampa della matrice per righe
for (i=0;i<altezza;i++)
{
for(j=0;j<larghezza;j++)
cout << mat[i][j] << " " ;
cout << endl;
}
// deallocazione della matrice
for (i=0;i<altezza;i++)
delete [] mat[i];
delete [] mat;
}
67. C++ Gestione Files
#include <iostream.h> // cout, cin, cerr ...
#include <stdlib.h> // ANSI Compatibilità, malloc...
#include <string.h> // strcpy...
#include <fstream.h> // file
void main(int argc, char* argv[])
{
char riga[1024];
// Creazione e scrittura di un file
ofstream ofile("appo.txt");
ofile << "Ciccio Cappuccio n";
ofile << "nato a Penna il 10/09/69 n";
ofile << "Via Matita, 5 n";
ofile << "72012 Libro(Lb) n";
ofile.close();
// Lettura di un file
ifstream ifile("appo.txt");
68. C++ Gestione Files
// Con questa modalità ci si ferma ogni SPACE
ifile >> riga;
cout << riga << endl;
// Lettura per righe
while (ifile.peek()!=-1)
{
ifile.getline(riga,1024);
cout << riga << "-" << ifile.peek() << endl;
}
ifile.close();
}
