Terza parte del Cheat Sheet per il C++
- Costruttori di copie
classname(const classname &ob) {
...
}
viene invocato solamente nelle inizializzazioni:
myclass x = y; // inizializzazione esplicita
func(y); // crea un oggetto temporaneo inizializzandolo a y
y = func(); // crea un oggetto temporaneo utilizzato per inizializzare y
x = y; // non è un'inizializzazione, quindi non richiama il costruttore di copie
- Puntatori a funzioni con overloading
se non c’è overloading si può fare:
p = func;
con overloading è necessario esplicitare i parametri:
int func(int a);
int func(int a, int b);
int main()
{
int (*p)(int a);
p = func; // punta a func con un solo parametro
- Argomenti standard delle funzioni
È possibile dichiarare parametri con valori di default nelle funzioni:
void func(int x=0)
{
...
}
...
func(5);
func();
i parametri standard devono essere specificati una sola volta (ad es. solo nel prototipo), i parametri standard devono comparire alla fine della lista dei parametri.
- Overloading degli operatori
tipo nomeclasse::operator#(elenco-argomenti) // # va sostituito con l'operatore che si vuole ridefinire
{
...
}
se l’operatore è unario non ci sono parametri (l’unico parametro è l’oggetto stesso, quindi this), se l’operatore è binario c’è un solo parametro (l’operando di destra, quello di sinistra è l’oggetto stesso, this)
forme prefisse e postfisse di ++ e –
tipo operator++(); // per ++var
tipo operator++(tipo o); // per var++
è possibile anche fare l’overloading delle forme abbreviate +=, -=, ecc. ecc.
le funzioni operator#() non possono avere argomenti standard e non si può fare l’overloading di ., ::, .*, ?
tranne che per =, le funzioni operator#() sono ereditate dalle classi derivate
- Overloading degli operatori tramite funzioni friend
in questo modo si devono esplicitare tutti gli operandi (in ordine da sinistra a destra), non è possibile per =, [], () e ->
per ++ e -- si deve utilizzare un parametro indirizzo, per le forme postfisse si usa un parametro aggiuntivo intero fittizio:
friend tipo operator++(tipo &ob, int x);
con le funzioni operator friend c’è maggiore flessibilità, ad esempio:
ob + 100; // ok sia con funzioni membro che con funzioni friend (il secondo parametro, o il primo nel caso di funzione membro, è dichiarato di tipo int)
100 + ob; // ok per le funzioni membro (basta dichiarare una versione con (int a, tipo b)), non è possibile con le funzioni membro perchè int è un tipo predefinito, quindi non posso ridefinire + per accettare il secondo operando del tipo di ob
- Overloading di new e delete
È possibile fare l’overloading:
void *operator new(size_t size);
void operator delete(void *p);
void *operator new[](size_t size); // per array
void operator delete[](void *p); // per array
- Overloading di []
tipo nomeclasse::operator[](int i); // per forza funzione membro
- Overloading di ()
utilizzata per creare una funzione che accette un certo numero di parametri:
...
tipo nomeclasse::operator()(int a, double b, mclass c);
...
int main()
{
myclass x;
nomeclasse ob1, ob2(10, 3.4, x); //per ob2 chiamo il costruttore, perchè è la forma abbreviata di ob2 = nomeclasse(10, 3.4, x) utilizzata per l'inizializzazione
ob1(2,23.2,x); // equivale a ob1.operator()(2,23.2,x), non chiama il costruttore
- Overloading di , (virgola)
in C++ è possibile fare l’overloading anche della virgola, operatore binario (il comportamento standard è quello di considerare in ordine i suoi operandi) es:
a = (b,c); // prima assegna b ad a, poi assegna c ad a
