使用什么类型的智能指针创建界面？

Question

我有一些代码可以生成这样的小部件：

std::unique_ptr<Widget1> Widget1::Create()
std::unique_ptr<Widget2> Widget2::Create()

现在我还有一段代码需要用到Widget1和Widget2。我希望它有一个类似的界面，但将小部件作为输入。

std::unique_ptr<Widget3> Widget3::Create(<?> Widget1, <?> Widget2)

在内部，Widget3 应该包含引用，例如

class Widget3
{
public:
   std::unique_ptr<Widget3> Create(<?> Widget1, <?> Widget2)
   {
      _widget1 = Widget1;
      _widget2 = Widget2;
   }
   void doSomething()
   {
      std::cout << _widget1->hello() << _widget2->hello();
   }
private:
   <?> _widget1, _widget2
};

现在我考虑过对 <?> 使用 std::shared_ptr 因为这似乎是最明智的。但是...我很困惑我应该如何传递它？

想法？

Answer 1

如果 Widget1 和 widget2 将仅作为 widget3 的成员存在，并且您以后不需要独立引用这些变量，您可以将它们作为值传递给 Widget3::create()

std::unique_ptr<Widget1> Widget1::Create()// returns a unique_ptr to widget1
std::unique_ptr<Widget2> Widget2::Create()// returns a unique_ptr to widget2

std::unique_ptr<Widget3> Create(std::unique_ptr<Widget1>  Widget1,
                                std::unique_ptr<Widget2>  Widget2)

否则，如果您希望将 Widget1 和 Widget2 的对象作为 Widget3 的共享对象，请对 widget1 和 widget2 使用 shared_ptr

Answer 2

这里的技巧是'separation of concerns'。

一个对象的生命周期与其实现是一个单独的问题。

shared_ptr 和 unique_ptr 控制 lifetime。小部件n 对象做事情。

如果您在代码设计中尊重关注点分离，您的生活将会很幸福，您的程序永远不会出错，您的同事也会喜欢您：

#include <iostream>
#include <memory>
#include <string>

struct Widget1 {
    std::string hello() { return "widget1"; }
};

struct Widget2 {
    std::string hello() { return "widget2"; }
};

struct Widget3 {
    // Widget3 objects share their components. This is now documented in the interface here...
    Widget3(std::shared_ptr<Widget1> widget1, std::shared_ptr<Widget2> widget2)
    : _widget1(std::move(widget1))
    , _widget2(std::move(widget2))
    {
    }

    void doSomething()
    {
        std::cout << _widget1->hello() << _widget2->hello();
    }
private:
    std::shared_ptr<Widget1> _widget1;
    std::shared_ptr<Widget2> _widget2;
};

using namespace std;

auto main() -> int
{
    // make a unique Widget3
    auto w1a = make_unique<Widget1>();
    auto w2a = make_unique<Widget2>();
    // note the automatic move-conversion from unique_ptr to shared_ptr
    auto w3a = make_unique<Widget3>(move(w1a), move(w2a));

    // make unique widget3 that uses shared components
    auto w1b = make_shared<Widget1>();
    auto w2b = make_shared<Widget2>();
    auto w3b = make_unique<Widget3>(w1b, w2b);

    // make shared widget3 that shares the same shared components as w3b
    auto w3c = make_shared<Widget3>(w1b, w2b);

    return 0;
}

不需要使用静态 ::create 函数。它对对象的创建者强制执行内存模型。

如果您想强制执行内存模型（例如始终创建共享指针），请使用共享句柄 pimpl 惯用语私下进行：

// Widget4 objects have shared-handle semantics.
struct Widget4
{
private:
    struct impl {
        std::string hello() const { return "hello4"; }
    };

public:
    Widget4()
    : _impl { std::make_shared<impl>() }
    {}

    std::string hello() const {
        return _impl->hello();
    }

private:
    std::shared_ptr<impl> _impl;
};

使用什么类型的智能指针创建界面？

Create interface with what type of smart pointer?

c++

smart-pointers