为班级成员使用智能指针

我在理解智能指针在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因为A 而无法使用getDevice()，对吧？那是我使用shared_ptrand的时候了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因为A 而无法使用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： 正如devicenullptrgetDevice()devicenullptr注释中所出现的那样，在这种情况下，所有权是唯一的，并且总是保证拥有对象（即内部数据成员永远不会存在），函数可以（也许应该）存在返回引用而不是指针。尽管这是真的，但我决定在此处返回一个原始指针，因为这是一个简短的答案，可以将其推广到where 可以的情况，并表明只要不使用原始指针就可以了手动内存管理。- 结束注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_ptr都被删除时，指针将被删除。如果需要来自的指针weak_ptr，lock则应使用来获取指针（如果存在）。