[c++] BOOST smart pointers

[Sabonis]

Qualcuno di voi usa gli smart pointers della libreria BOOST? Mi interessa sopratutto shared ptr. Quali sono i vantaggi, quali i limiti?
Mi sapete consigliare qualche libro/tutorial?

[PhysX]

Gli shared_ptr son molto utili, soprattutto quando è necessario usare un puntatore all'interno di tanti moduli diversi e diventa difficile capire qundo puo essere cancellato senza generare memory leak o doppi delete.
Ad esempio se un metodo di una classe scritta da un altro ritorna uno shared_ptr invece di un puntatore si risolve il problema di sapere se deve essere il chiamante a liberare la memoria o se ci pensa l'oggetto stesso ad esempio.

Quando posso gli uso nei miei programmi, ma purtroppo molte (se non tutte) delle librerie in c++ esistenti non gli utilizzano e di conseguenza è scomodo dover convertire da shared_ptr e puntatore e viceversa ogni volta che devo passare un puntatore a una funzione della libreria o leggere il valore di ritorno.


#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

typedef shared_ptr<myData> myPtr;

myPtr fun() {
myPtr result(new myData(...));
result->doSomething();
...
return result;
}

int main() {
myPtr p=fun();

il vantaggio è che a questo punto puoi usare p senza preoccuparti di doverlo cancellare, passarlo ad altre funzioni, copiarlo etc sapendo che verra cancellato da solo quando non sara piu usato.


In realta ci possono essere ancora problemi quando due shared_ptr si puntano tra di loro. Ad esempio se implmementi un albero in cui i parent e i child si puntano tramite shared_ptr nel momento in cui cancelli lo shared_ptr che punta alla radice dell'albero questo non viene cancellato perche siccome i parent e i child continuano a puntarsi a vicenda il reference counter non scende a zero e non vengono rimossi, in pratica tutto l'albero resta allocato in memoria fino alla fine del programma.

Per risolvere questo inconveniente i usano i weak_ptr in accoppiata con gli shared_ptr. i weak_ptr in sostanza puntano a un oggetto ma senza incrementare il reference counter, quindi è come se non ci fossero, e quando serve ritrnano uno shared_ptr da usare localmente in modo che quando si esce dallo scope viene cancellato.

[Sabonis]

Grazie mille. Non hai qualche libro o qualche guida da consigliarmi?

[PhysX]

sono semplici da usare, non serve tanta roba. prova questi:
http://www.ddj.com/cpp/184401507
http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm

questo è un semplice smart pointer che mi ero fatto per non dover linkare boost, è simile a shared_ptr come funzionamento ma piu semplice come implementazione, puoi usarlo per capire come funziona il meccanismo:

template <class T>
class sm {
private:
T* obj;
int* count;
public:
sm() {
obj=0;
count=0;
}
sm(T* src) {
obj=src;
if (src) {
count=new int(1);
}
else {
count=0;
}
}
sm<T>& operator=(T* src) {
reset();
obj=src;
count=new int(1);
return *this;
}
sm<T>& operator=(const sm<T>& src) {
copy(src);
return *this;
}
void reset() {
if (obj && count) {
(*count)--;
if (*count<=0) {
delete obj;
delete count;
}
}
obj=0;
count=0;
}
bool operator==(const sm<T>& src) {
return this==&src;
}
bool operator!=(const sm<T>& src) {
return this!=&src;
}
bool equals(const sm<T>& src) {
return obj == src.obj;
}
void copy(const sm<T>& src) {
reset();
obj=src.obj;
count=src.count;
(*count)++;
}
T& operator*() {
return *obj;
}
T* operator->() {
return obj;
}
~sm() {
reset();
}
};
e si usa come un normale shared_ptr:

sm<myData> ptr(new myData);
ptr->doSomething();
myData obj=*ptr;

[Sabonis]

Grazie ancora.
Ma tu ad esempio usi solo smart pointers oppure usi una combinazione di smart pointers e puntatori normali?

Il problema delle dipendenze "circolari" si verifica solo quando la dipenza è diretta? Se A contiene un puntatore a B e B contiene un puntatore a C che contiene un puntatore ad A non c'è nessun problema vero?

[fero86]

Qualcuno di voi usa gli smart pointers della libreria BOOST? Mi interessa sopratutto shared ptr. Quali sono i vantaggi, quali i limiti? io non uso quelli della libreria Boost, peró in generale faccio spesso uso di smart pointers e in generale scoped objects. il vantaggio principale dell'incapsulare una risorsa allocata dinamicamente all'interno di uno scoped object é quello di non doversi preoccupare della sua deallocazione N volte, bensí una volta sola all'interno del distruttore. l'esempio tipico viene quando hai a che fare con COM (non a caso ATL fa uso pesante di scoped objects); per capire il vantaggio degli smart pointers ti consiglio di leggerti in MSDN la documentazione della classe CComPtr, che si occupa automaticamente di rilasciare un puntatore ad interfaccia COM.
qui é spiegato perfettamente: http://msdn.microsoft.com/en-us/library/ezzw7k98.aspx


@PhysX: alcune note sul tuo codice.
template <class T>
class sm {
private:
T* obj;
int* count;
public:
sm() {
obj=0;
count=0;
}
sm(T* src) {
obj=src;
if (src) {
count=new int(1);
}
else {
count=0;
}
}
sm<T>& operator=(T* src) {
reset();
obj=src;
count=new int(1);
return *this;
}
sm<T>& operator=(const sm<T>& src) {
copy(src);
return *this;
}
void reset() {
if (obj && count) {
(*count)--;
if (*count<=0) {
delete obj;
delete count;
}
}
obj=0;
count=0;
}
bool operator==(const sm<T>& src) {
return this==&src;
}
bool operator!=(const sm<T>& src) {
return this!=&src;
}
bool equals(const sm<T>& src) {
return obj == src.obj;
}
void copy(const sm<T>& src) {
reset();
obj=src.obj;
count=src.count;
(*count)++;
}
T& operator*() {
return *obj;
}
T* operator->() {
return obj;
}
~sm() {
reset();
}
}; ti consiglio di aggiungere questi operatori:

inline const T &operator * () const
{
return *obj;
}

inline const T *operator -> () const
{
return obj;
}

inline operator T* ()
{
return obj;
}

inline operator const T* () const
{
return obj;
}
e di mettere const ai metodi che non modificano l'oggetto :)


Grazie ancora.
Ma tu ad esempio usi solo smart pointers oppure usi una combinazione di smart pointers e puntatori normali? mi intrometto nella discussione :)
io trovo vantaggioso usare degli scoped objects (anche se scritti ad hoc) praticamente sempre: sia per lavoro che per hobby é raro che mi capiti di dover gestire una risorsa dinamica (cioé una risorsa allocata dinamicamente che poi bisogna ricordarsi di deallocare) in maniera "banale", cioé di allocarla e di poterla deallocare con una sola istruzione al termine dell'algoritmo; se questo accade significa che l'algoritmo era molto semplice perché non prevedeva di fallire in nessun punto tra l'allocazione e la deallocazione della risorsa.