Utilisation de pointeurs intelligents pour les membres de la classe

J'ai du mal à comprendre l'utilisation des pointeurs intelligents en tant que membres de classe dans C ++ 11. J'ai beaucoup lu sur les pointeurs intelligents et je pense comprendre comment unique_ptret shared_ptr/ weak_ptrfonctionne en général. Ce que je ne comprends pas, c'est l'usage réel. Il semble que tout le monde recommande de l'utiliser unique_ptrpresque tout le temps. Mais comment pourrais-je implémenter quelque chose comme ceci:

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

Disons que je voudrais remplacer les pointeurs par des pointeurs intelligents. Un unique_ptrne fonctionnerait pas à cause de getDevice(), non? C'est donc le moment où j'utilise shared_ptret weak_ptr? Pas moyen d'utiliser unique_ptr? Il me semble que dans la plupart des cas, shared_ptrcela a plus de sens, sauf si j'utilise un pointeur dans une très petite portée?

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

Est-ce la voie à suivre? Merci beaucoup!

Un unique_ptrne fonctionnerait pas à cause de getDevice(), non?

Non pas forcément. L'important ici est de déterminer la politique de propriété appropriée pour votre Deviceobjet, c'est-à-dire qui sera le propriétaire de l'objet pointé par votre pointeur (intelligent).

Est-ce que ce sera l'instance de l' Settingsobjet seul ? L' Deviceobjet devra-t-il être détruit automatiquement lorsque l' Settingsobjet sera détruit, ou devrait-il survivre à cet objet?

Dans le premier cas, std::unique_ptrc'est ce dont vous avez besoin, car il fait Settingsle seul (unique) propriétaire de l'objet pointé, et le seul objet qui est responsable de sa destruction.

Sous cette hypothèse, getDevice()devrait retourner un simple pointeur d' observation (les pointeurs d'observation sont des pointeurs qui ne maintiennent pas l'objet pointé en vie). Le type le plus simple de pointeur d'observation est un pointeur brut:

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

[ NOTE 1: Vous vous demandez peut-être pourquoi j'utilise des pointeurs bruts ici, alors que tout le monde n'arrête pas de dire que les pointeurs bruts sont mauvais, dangereux et dangereux. En fait, c'est un avertissement précieux, mais il est important de le mettre dans le bon contexte: les pointeurs bruts sont mauvais lorsqu'ils sont utilisés pour effectuer une gestion manuelle de la mémoire , c'est-à-dire allouer et désallouer des objets via newet delete. Lorsqu'ils sont utilisés uniquement comme un moyen d'atteindre une sémantique de référence et de faire circuler des pointeurs d'observation non propriétaires, il n'y a rien d'intrinsèquement dangereux dans les pointeurs bruts, sauf peut-être le fait qu'il faut veiller à ne pas déréférencer un pointeur suspendu. - FIN NOTE 1 ]

[ NOTE 2: Comme il est apparu dans les commentaires, dans ce cas particulier où la propriété est unique et où l'objet possédé est toujours garanti d'être présent (c'est-à-dire que le membre de données interne devicene le sera jamais nullptr), la fonction getDevice()pourrait (et devrait peut-être) renvoie une référence plutôt qu'un pointeur. Bien que cela soit vrai, j'ai décidé de renvoyer un pointeur brut ici parce que je voulais dire que c'était une réponse courte que l'on pourrait généraliser au cas où cela devicepourrait être nullptr, et pour montrer que les pointeurs bruts sont OK tant que l'on ne les utilise pas pour gestion manuelle de la mémoire. - FIN NOTE 2 ]

La situation est bien sûr radicalement différente si votre Settingsobjet ne doit pas avoir la propriété exclusive de l'appareil. Cela pourrait être le cas, par exemple, si la destruction de l' Settingsobjet ne devait pas également impliquer la destruction de l' Deviceobjet pointé .

C'est quelque chose que seul vous, en tant que concepteur de votre programme, pouvez dire; d'après l'exemple que vous donnez, il m'est difficile de dire si c'est le cas ou non.

Pour vous aider à le comprendre, vous pouvez vous demander s'il existe d'autres objets en dehors de ceux Settingsqui ont le droit de maintenir l' Deviceobjet en vie tant qu'ils tiennent un pointeur vers lui, au lieu d'être simplement des observateurs passifs. Si tel est effectivement le cas, vous avez besoin d'une politique de propriété partagée , qui 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...
}

Remarquez qu'il weak_ptrs'agit d'un pointeur d' observation , pas d'un pointeur propriétaire - en d'autres termes, il ne maintient pas l'objet pointé en vie si tous les autres pointeurs propriétaires vers l'objet pointé sont hors de portée.

L'avantage par weak_ptrrapport à un pointeur brut ordinaire est que vous pouvez dire en toute sécurité s'il weak_ptrest suspendu ou non (c'est-à-dire s'il pointe vers un objet valide ou si l'objet pointé à l'origine a été détruit). Cela peut être fait en appelant la expired()fonction membre sur l' weak_ptrobjet.

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_ptrest utilisé uniquement pour les boucles de référence. Le graphe de dépendances doit être un graphe dirigé acyclique. Dans les pointeurs partagés, il existe 2 décomptes de références: 1 pour shared_ptrs et 1 pour tous les pointeurs ( shared_ptret weak_ptr). Lorsque tous les shared_ptrs sont supprimés, le pointeur est supprimé. Lorsque le pointeur est nécessaire à partir de weak_ptr, lockdoit être utilisé pour obtenir le pointeur, s'il existe.