Utilizzo di puntatori intelligenti per i membri della classe

Sto riscontrando problemi nel comprendere l'utilizzo dei puntatori intelligenti come membri della classe in C ++ 11. Ho letto molto sui puntatori intelligenti e penso di capire come unique_ptre shared_ptr/ o weak_ptrlavorare in generale. Quello che non capisco è il reale utilizzo. Sembra che tutti raccomandino di usarlo unique_ptrcome modo per andare quasi sempre. Ma come implementerei qualcosa del genere:

class Device {
};

class Settings {
    Device *device;
public:
    Settings(Device *device) {
        this->device = device;
    }

    Device *getDevice() {
        return device;
    }
};    

int main() {
    Device *device = new Device();
    Settings settings(device);
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

Diciamo che vorrei sostituire i puntatori con puntatori intelligenti. A unique_ptrnon funzionerebbe a causa di getDevice(), giusto? Quindi è il momento in cui uso shared_ptre weak_ptr? Nessun modo di usare unique_ptr? Mi sembra che per la maggior parte dei casi shared_ptrabbia più senso se non sto usando un puntatore in un ambito davvero piccolo?

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> device) {
        this->device = device;
    }

    std::weak_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::weak_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

È questa la strada da percorrere? Grazie mille!

A unique_ptrnon funzionerebbe a causa di getDevice(), giusto?

No, non necessariamente. Ciò che è importante qui è determinare la politica di proprietà appropriata per il tuo Deviceoggetto, ovvero chi sarà il proprietario dell'oggetto a cui punta il tuo puntatore (intelligente).

E 'intenzione di essere l'istanza Settingsdell'oggetto da solo ? L' Deviceoggetto dovrà essere distrutto automaticamente quando l' Settingsoggetto viene distrutto o dovrebbe sopravvivere a quell'oggetto?

Nel primo caso, std::unique_ptrè ciò di cui hai bisogno, poiché rende Settingsl'unico (unico) proprietario dell'oggetto appuntito e l'unico oggetto responsabile della sua distruzione.

In base a questo presupposto, getDevice()dovrebbe restituire un semplice puntatore osservante (i puntatori osservanti sono puntatori che non mantengono in vita l'oggetto appuntito). Il tipo più semplice di osservazione puntatore è un puntatore non elaborato:

#include <memory>

class Device {
};

class Settings {
    std::unique_ptr<Device> device;
public:
    Settings(std::unique_ptr<Device> d) {
        device = std::move(d);
    }

    Device* getDevice() {
        return device.get();
    }
};

int main() {
    std::unique_ptr<Device> device(new Device());
    Settings settings(std::move(device));
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

[ NOTA 1: ti starai chiedendo perché sto usando puntatori non elaborati qui, quando tutti continuano a dire che i puntatori non elaborati sono dannosi, non sicuri e pericolosi. In realtà, questo è un avvertimento prezioso, ma è importante metterlo nel contesto corretto: i puntatori non elaborati sono dannosi quando vengono utilizzati per eseguire la gestione manuale della memoria , vale a dire l'allocazione e la deallocazione di oggetti attraverso newe delete. Se usato esclusivamente come mezzo per raggiungere la semantica di riferimento e passare attorno al non-possesso, osservando i puntatori, non c'è nulla di intrinsecamente pericoloso nei puntatori grezzi, tranne forse per il fatto che si dovrebbe fare attenzione a non dedurre un puntatore penzolante. - FINE NOTA 1 ]

[ NOTA 2: Come è emerso nei commenti, in questo caso particolare in cui la proprietà è unica e l'oggetto di proprietà è sempre garantito per essere presente (ovvero il membro di dati interno devicenon sarà mai nullptr), la funzione getDevice()potrebbe (e forse dovrebbe) restituisce un riferimento anziché un puntatore. Mentre questo è vero, ho deciso di tornare un puntatore prime qui perché volevo dire che questo è un breve risposta che si potrebbe generalizzare al caso in cui devicepotrebbe essere nullptr, e per dimostrare che i puntatori prime sono OK finché non li si usa per gestione manuale della memoria. - FINE NOTA 2 ]

La situazione è radicalmente diversa, ovviamente, se il tuo Settingsoggetto non deve avere la proprietà esclusiva del dispositivo. Questo potrebbe essere il caso, ad esempio, se la distruzione Settingsdell'oggetto non dovesse implicare anche la distruzione Devicedell'oggetto appuntito .

Questo è qualcosa che solo tu come designer del tuo programma puoi dire; dall'esempio che fornisci, è difficile per me dire se è così o no.

Per aiutarti a capirlo, potresti chiederti se ci sono altri oggetti oltre a quelli Settingsche hanno il diritto di mantenere l' Deviceoggetto in vita fintanto che tengono un puntatore su di esso, invece di essere solo osservatori passivi. In tal caso, è necessaria una politica di proprietà condivisa , che è ciò che std::shared_ptroffre:

#include <memory>

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> const& d) {
        device = d;
    }

    std::shared_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device = std::make_shared<Device>();
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

Si noti che si weak_ptrtratta di un puntatore osservatore , non di un puntatore proprietario - in altre parole, non mantiene in vita l'oggetto appuntito se tutti gli altri puntatori proprietari dell'oggetto puntato escono dall'ambito.

Il vantaggio di weak_ptroltre un normale puntatore raw è che puoi tranquillamente dire se weak_ptrè penzolante o meno (cioè se sta puntando a un oggetto valido o se l'oggetto originariamente indicato è stato distrutto). Questo può essere fatto chiamando la expired()funzione membro weak_ptrsull'oggetto.

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(const std::shared_ptr<Device>& device) : device(device) {

    }

    const std::shared_ptr<Device>& getDevice() {
        return device;
    }
};

int main()
{
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice(settings.getDevice());
    // do something with myDevice...
    return 0;
}

week_ptrviene utilizzato solo per i loop di riferimento. Il grafico delle dipendenze deve essere un grafico indiretto aciclico. Nei puntatori condivisi ci sono 2 conteggi di riferimento: 1 per shared_ptrs e 1 per tutti i puntatori ( shared_ptre weak_ptr). Quando tutti shared_ptri messaggi vengono rimossi, il puntatore viene eliminato. Quando è necessario il puntatore da weak_ptr, lockdovrebbe essere usato per ottenere il puntatore, se esiste.