Использование умных указателей для учеников

У меня проблемы с пониманием использования умных указателей в качестве членов класса в C ++ 11. Я много читал об умных указателях и думаю, что понимаю, как unique_ptrи shared_ptr/ или weak_ptrработаю в целом. То, что я не понимаю, является реальным использованием. Кажется, что все рекомендуют использовать unique_ptrкак способ идти почти все время. Но как бы я реализовать что-то вроде этого:

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

Допустим, я хотел бы заменить указатели умными указателями. А unique_ptrне будет работать из-за getDevice(), верно? Так что это время, когда я использую shared_ptrи weak_ptr? Нет способа использования unique_ptr? Мне кажется, что в большинстве случаев shared_ptrимеет больше смысла, если я не использую указатель в очень маленькой области видимости?

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

Это путь? Огромное спасибо!

А unique_ptrне будет работать из-за getDevice(), верно?

Нет, не обязательно Здесь важно определить подходящую политику владения для вашего Deviceобъекта, т.е. кто будет владельцем объекта, на который указывает ваш (умный) указатель.

Это собирается быть экземпляр Settingsобъекта в одиночку ? Придется Deviceли уничтожать Settingsобъект автоматически при его разрушении или он переживет этот объект?

В первом случае std::unique_ptrэто то , что вам нужно, так как он делает Settingsединственным (уникальным) владельцем указанного объекта и единственным объектом, который отвечает за его уничтожение.

В соответствии с этим предположением getDevice()следует возвращать простой указатель наблюдения (указатели наблюдения - это указатели, которые не поддерживают указанный объект в живых). Самым простым видом указателя наблюдения является необработанный указатель:

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

[ ПРИМЕЧАНИЕ 1: Вам может быть интересно, почему я здесь использую сырые указатели, когда все говорят, что необработанные указатели плохие, небезопасные и опасные. На самом деле, это ценное предупреждение, но важно поместить его в правильный контекст: необработанные указатели плохи, когда используются для ручного управления памятью , то есть для выделения и освобождения объектов через newи delete. При использовании исключительно в качестве средства для достижения ссылочной семантики и обхода несобственников при наблюдении указателей в исходных указателях нет ничего опасного, за исключением, возможно, того факта, что следует избегать разыменования висящего указателя. - КОНЕЦ ПРИМЕЧАНИЕ 1 ]

[ ПРИМЕЧАНИЕ 2: Как выяснилось в комментариях, в этом конкретном случае, когда право собственности является уникальным и всегда гарантированно присутствует принадлежащий объект (т. Е. Внутренний элемент данных deviceникогда не будет nullptr), функция getDevice()может (и, возможно, должна) вернуть ссылку, а не указатель. Хотя это и правда, я решил вернуть здесь необработанный указатель, потому что я имел в виду, что это будет краткий ответ, который можно обобщить на случай, где это deviceвозможно nullptr, и показать, что необработанные указатели в порядке, если их не использовать для ручное управление памятью. - КОНЕЦ ПРИМЕЧАНИЕ 2 ]

Конечно, ситуация радикально отличается, если ваш Settingsобъект не должен иметь исключительное право собственности на устройство. Это может иметь место, например, если разрушение Settingsобъекта не должно также подразумевать разрушение заостренного Deviceобъекта.

Это то, что может сказать только вы, как разработчик вашей программы; из приведенного вами примера мне трудно сказать, так ли это на самом деле.

Чтобы помочь вам понять это, вы можете спросить себя, есть ли какие-либо другие объекты, кроме тех, Settingsкоторые имеют право поддерживать Deviceобъект в течение всего времени, пока он удерживает указатель на него, вместо того, чтобы быть просто пассивными наблюдателями. Если это действительно так, то вам нужна политика совместного владения , которая std::shared_ptrпредлагает следующее:

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

Обратите внимание, что weak_ptrэто указатель- наблюдатель , а не указатель-владелец - другими словами, он не поддерживает указательный объект живым, если все другие указатели на указанный объект выходят из области видимости.

Преимущество weak_ptrнад регулярным сырым указателем является то , что вы можете смело сказать , является ли weak_ptrэто оборванный или нет (то есть ли это указует на действительный объект, или если объект , первоначально указал было разрушено). Это можно сделать, вызвав expired()функцию-член weak_ptrобъекта.

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_ptrиспользуется только для эталонных циклов. Граф зависимостей должен быть ациклически ориентированным графом. В общих указателях есть 2 счетчика ссылок: 1 для shared_ptrs и 1 для всех указателей ( shared_ptrи weak_ptr). Когда все shared_ptrs удалены, указатель удаляется. Когда указатель необходим от weak_ptr, lockдолжен использоваться для получения указателя, если он существует.