Piccolo Cheat Sheet per il C++ parte 1

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.

Lascia un commento

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...