Questo post segue il precedente “Piccolo Cheat Sheet per il C” (diviso in più parti) e tratta delle caratteristiche principali del C++
- Tipi di dati
wchar (caratteri a 16 bit, i letterali si indicano con L’char’)
- Classi
class nomeClasse {
dati e funzioni privati // private è opzionale
specificatori di accesso: //private, public, protected
dati e funzioni // normalmente si mette solo il prototipo delle funzioni
specificatori di accesso:
dati e funzioni
} elenco oggetti; // dichiarazione contemporanea alla definizione
tipo myclass::funzione(parametri) //implementazione
{
...
}
si può usare anche struct per definire una classe invece di class, la differenza sta nel fatto che di default con class i dati e le funzioni sono private, mentre con struct sono public (la stessa cosa vale anche per le union)
- unioni anonime
in C++ si possono dichiarare unioni anonime, es:
int main()
{
union {
long l;
double d;
};
...
l = 1000000;
d = 123.2342;
...
si usano direttamente le variabili membro dell’unione, come se fossero variabili normali.
- Funzioni friend
possono accedere agli oggetti private della classe di cui sono friend (non sono membri della classe)
class nome {
...
friend tipo funzione(parametri);
...
}
tipo funzione(parametri)
{
...
}
int main()
{
...
funzione(parametri);
...
}
- Classi friend
class nome {
...
friend class nome1;
...
};
class nome1 {
...
}
gli oggetti di tipo nome1 hanno accesso a tutti i dati privati della classe nome.
- Funzioni inline
inline tipo funzione(parametri) // globale
{
...
}
funziona come una macro del C (il compilatore la sostisuisce ogni volta che viene richiamata, se è possibile)
si può fare anche per le funzioni membro di una classe, dichiarando il prototipo normalmente e specificando inline nell’implementazione della funzione, oppure si può mettere l’implementazione all’interno della definizione della classe, al posto del prototipo (in questo caso non è necessario aggiungere inline)
- Costruttori e istanze
Se il costruttore non ha parametri o non c’è il costruttore si può evitare di specificarlo e l’istanziazione avviene come nel caso di normali variabili:
myclass a, b; // gli oggetti sono istanziati
a.xy = 10; // posso utilizzarli subito
se il costruttore ha un parametro l’inizializzazione può essere fatta così:
myclass a = 10; //ammettendo che il costruttore di myclass sia del tipo myclass(int x) { xy = x; }
se il costruttore ha 2 o più parametri l’inizializzazione può essere fatta così (vale anche per 1 o 0 parametri)
myclass a(10, 3.4); // equivale a myclass a = myclass(10, 3.4)
per dichiarare un array:
myclass a[3]; //deve esserci il costruttore senza parametri
il costruttore di un oggetto può essere richiamato in seguito come un normale metodo:
myclass ob;
ob = myclass(par1, par2);
- membri static di una classe
è possibile usare static per attributi membro di una classe, questi sono condivisi per tutti gli oggetti della classe. è necessario definire esplicitamente le variabili static esternamente alla classe:
class nome {
static int x; // in questo caso x è privata
....
}
int nome::x; //definisco la variabile e alloco la relativa memoria, se x fosse stata pubblica, per accedervi esternamente alla classe si usa l'operatore :: (nome::x = 10)
le funzioni static operano solo su variabili static e non possono essere virtuali, const o volatile, si accede ad esse con ::
- operatore ::
:: si usa anche per accedere a variabili globali quando sono ridefinite localmente, ad es:
int x;
int main()
{
int x;
x = 4; // accesso alla variabile locale
::x = 10; // accesso alla variabile globale
...
}
- Classi nidificate e interne a funzioni
È possibile dichiarare delle classi interne ad altre classi e classi interne al corpo di una funzione, in entrambi i casi ne limito la visibilità al solo elemento dentro cui sono dichiarate
- Passaggio di oggetti a funzioni
quando si passa un oggetto ad una funzione, l’oggetto è passato per valore, quindi si crea una copia dell’oggetto originale, ma non viene richiamato il costruttore, la copia avviene bit per bit, questo potrebbe essere un problema nel caso in cui l’oggetto allochi memoria, perchè le due copie condividono la stessa area di memoria, quindi all’uscita della funzione l’area di memoria viene rimossa e l’oggetto originale non può più accedervi.
- Restituzione di oggetti da parte di funzioni
viene restituito un oggetto temporaneo creato dalla funzione e al termine della funzione l’oggetto viene distrutto, questo può portare a problemi come quelli espressi nel punto sopra.
- Assegnamento fra oggetti
myclass a,b:
a = b; // effettua una copia bit a bit, quindi stessi problemi descritti sopra.
