Piccolo Cheat Sheet per il C++ parte 2

Seconda parte del Cheat Sheet per il C++

  • Array di oggetti

myclass a[3]; //possibile solo se myclass dichiara un costruttore vuoto

myclass a[] = {1,3,5}; // possibile solo se il costruttore riceve un solo parametro, in questo caso un int, non è necessario specificare la dimensione

myclass a[] = { myclass(1, 2), myclass(2,4), myclass(4,8)}; // se il costruttore ha più di un parametro, in questo caso 2, non è necessario specificare la dimensione

  • Puntatori a oggetti

myclass *p, ob;

p = &ob;

p->funzione(par); // equivale a ob.funzione(par);

this // è un puntatore, quindi si usa ->

i puntatori a classi base non possono richiamare elementi delle classi derivate (cfr. in Java)

  • puntatori a un membro di una classe

in C++ è possibile definire un puntatore a un membro di una classe (il membro, che può essere una funzione o un attributo, deve essere public):

class myclass {

public:

int val;

int f();

}

int main()

{

int myclass::*data;

int (myclass::*func)();

myclass ob;

data = &myclass::val;

func = &myclass::f;

cout << ob.*data;

cout << (ob.*func)();

}

si può accedere ai puntatori a membro solamente con gli operatori speciali .* (vedi sopra) e ->* (se invece di usare ob, si usava un puntatore a un oggetto myclass)

  • Indirizzi

evoluzione del concetto di puntatore, molto più comodi per il passaggio di parametri (appunto) per indirizzo (sono puntatori "impliciti")

int f(int &par)

{

par = 5;

}

int main()

{

int x = 2;

x = f(x); // adesso x vale 5

}

le funzioni possono anche ritornare indirizzi:

char array[10] = "pippo pluto";

char &f(int x)

{

return array[x]; // restituisce l'indirizzo del x-esimo carattere dell'array

}

int main()

{

f(5) = "&"; // assegna "&" all'indirizzo restituito da f

cout << array; // stampa pippo&pluto

}

l’indirizzo ritornato non deve far riferimento ad un oggetto interno alla funzione stessa, altrimenti si restituisce un indirizzo non consistente

un indirizzo di una classe base può essere utilizzato anche per oggetti di classi derivate (come per i puntatori)

  • indirizzi indipendenti

sono variabili dichiarate come indirizzi, in pratica permettono la definizione di un alias di un’altra variabile

int main()

{

int a;

int &ind = a; // ora ind e a sono due nomi che indicano la stessa variabile

}

  • NB

int* a, b; // a è un puntatore a un intero, ma b no, b è un intero

int *a, b; // equivalente a quella sopra ma decisamente più chiara

  • Operatori di allocazione dinamica della memoria

new permette di allocare dinamicamente la memoria:

tipo *a = new tipo;

int *x = new int;

myclass *x = new myclass;

inizializzazione

int *x = new int (5);

allocazione array

tipo *p = new tipo[dim]

allocazione di oggetti

myclass *p = new myclass; // se myclass non definisce un costruttore

myclass *p = new myclass(par1, par2); // se myclass ha un costruttore con eventuali parametri

myclass *p = new myclass[3]; // array di 3 elementi, myclass DEVE avere un costruttore senza parametri, non si può inizializzare un array creato con new

new si usa all’interno di un try-catch:

try {

p =new myclass(a, b);

} catch(bad_alloc xa) {

cout << "errore";

}

delete permette la cancellazione (come free(p)):

delete p; // per variabili singole

delete[] p; // per array

se non si vuole usare il try-catch per new si può usare la seguente forma:

p = new(nothrow) tipo(a,b);

if(!p) { // se la new fallisce p==null

cout << "errore";

}

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...