[C++] Uso delle graffe

[lucia983]

Premetto che non sono un esperta di C++.. sto cercando di implementare l'algoritmo di dijkstra e ho trovato delle librerie da sfruttare.. in una di queste c'è la classe "Adj_elem"

...

adj_elem(vertice* adj_vertex_ = 0, int dist_ = 0)
: adj_vertex(adj_vertex_)
, dist(dist_)
{}

adj_elem(const adj_elem& e)
: adj_vertex(e.adj_vertex)
, dist(e.dist)
{}

~adj_elem()
{}
};


A cosa serve aprire e chiudere le graffe senza nulla all'interno?

[zero85]

Nulla questi sono semplicemente costruttore, costruttore di copia e distruttore della classe che non compiono nessuna azione esplicita, mentre implicitamente nel costruttore:

adj_vertex = adj_vertex_;
dist = dist_;

e nel costruttore di copia:

adj_vertex = e.adj_vertex;
dist = e.dist;

[lucia983]

Visto che ci sto posso permettermi di chiedere pure il sigificato di questo pezzo:
"adj_elem(vertice* adj_vertex_ = 0, int dist_ = 0)
: adj_vertex(adj_vertex_)
, dist(dist_)"

Ancora grazie!

[zero85]

Allora è abbastanza semplice:

adj_elem(vertice* adj_vertex_ = 0, int dist_ = 0)
: adj_vertex(adj_vertex_)
, dist(dist_)
{
}

equivarrebbe a scrivere:

adj_elem(vertice* adj_vertex_ = 0, int dist_ = 0)
{
adj_vertex = adj_vertex_;
dist = dist_;
}

E' solamente un metodo "diverso" per inizializzare i membri di una classe ed è migliore da usare in quanto in presenza di eccezzioni ci sarebbe una deallocazione delle risorse "migliore".

Ti faccio un esempio pratico. Allora prima di tutto una premessa in c++ un oggetto si ritiene creato quando il suo costruttore termina con successo.

Prendiamo la classe teorica A:

template <typename T>
class A
{
    private:
        int size;
	T *member;
        T *member2;
    public:
        //costruttore
        //costruttore di copia
        //distruttore
};

ora ipotizziamo di aver definito il costruttore così:

A(int s)
{
     size = s;
     member = new T[size];
     member2 = new T[size];
}

e così il distruttore:

~A()
{
    delete[] member;
    delete[] member2;
}

se per qualche motivo l'allocazione di member 2 dovesse fallire, viene lanciata un eccezione di bad alloc e il costruttore non viene eseguito interamente, dunque l'oggetto non viene considerato costruito, il che implica che all'uscita dal blocco in cui l'oggetto stesso è stato definito esso non verrà distrutto, ma il suo membro member rimarrà allocato comportando uno spereco di memoria.

Ora vediamo il caso in cui il costruttore sia definito così:

A(int s): size(s):member(new T[size]):member2(new T[size])
{
}

mentre il distruttore rimarrà uguale.

Supponiamo come prima che l'allocazione di member2 fallisca, cosa succede? Il costruttore viene eseguito completamente in quanto l'eccezione non viene provocata dal costruttore, ma dal tentativo di inizializzare i membri. Questo comporta che all'uscita del blocco in cui è definito l'oggetto il distruttore viene chiamato e si dealloca la memoria usata da member, ottimizzando le risorse.

Spero di essere stato chiaro e di non avere detto castronerie, ormai i miei ricordi di metodologie di programmazione si affievoliscono