Boost shared_ptr

Da Beyond the C++ Standard Library: An Introduction to Boost, di Björn Karlsson.

shared_ptr

Lo smart pointer shared_ptr é reference counted allo scopo di permettere la condivisione dell'oggetto sottostante tra diverse istanze. Il distruttore dell'oggetto viene chiamato quando il reference count scende a zero.

Ecco un esempio con shared_ptr:

#include<iostream>
#include<boost/shared_ptr.hpp>

using namespace std;
using namespace boost;

class A {
    shared_ptr<int> no_;
public:
    A(shared_ptr<int> no) : no_(no) {
    }

    void value(int i) {
        *no_ = i;
    }
};

class B {
    shared_ptr<int> no_;
public:
    B(shared_ptr<int> no) : no_(no) {
    }

    int value() const {
        return *no_;
    }
};

int main() {
    shared_ptr<int> temp(new int(14));

    if (temp.unique())
        cout << "Unique" << endl;

    A a(temp);
    if (temp.unique() == false)
        cout << "Not anymore unique" << endl;

    B b(temp);
    cout << "Reference count now is " << temp.use_count() << endl;

    temp.reset();

    a.value(28);
    cout << "b value now is " << b.value() << endl;
}

Definiamo due classi che usano al loro interno un shared_ptr che viene creato per copia.

Nel main creiamo temp, un shared_ptr, verifichiamo che la risorsa sottostante sia inzialmente unica; creiamo un oggetto A, passando una copia di temp, verifichiamo che il reference count sia stato incrementato, unique() é ora false, creiamo un oggetto B e vediamo che ora il reference count é posto a tre. Con una chiamata a reset() sleghiamo temp dalla risorsa sottostante; cambiamo il valore associato ad a e vediamo che questo cambiamento si riflette in b.

Uno degli usi di shared_ptr é in combinazione dei container STL. Il bello é che anche il polimorfismo viene gestito correttamente, come vediamo in quest'altro esempio:

#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>

using namespace std;
using namespace boost;

class A {
public:
    virtual void sing() = 0;
protected:
    virtual ~A() {
    };
};

class B : public A {
public:
    virtual void sing() {
        cout << "Do re mi fa so la" << endl;
    }
};

shared_ptr<A> createA() {
    shared_ptr<A> p(new B());
    return p;
}

int main() {
    typedef vector<shared_ptr<A> > containerType;
    typedef containerType::iterator iterator;

    containerType container;
    for (int i = 0; i < 10; ++i) {
        container.push_back(createA());
    }

    cout << "The choir is gathered:" << endl;
    iterator end = container.end();
    for (iterator it = container.begin(); it != end; ++it) {
        (*it)->sing();
    }
}