如何存储指向该类不拥有的对象的指针？

Question

我正在尝试编写两个类 FooFactory 和 Foo。 FooFactory 在构造函数中初始化一个对象 ToolBox 并将其存储在 unique_ptr 中，因为我希望在工厂被破坏后对其进行清理。 Foo 的所有实例都应该能够使用 ToolBox，因此我在 Foo 的构造函数中将 ptr 传递给 ToolBox 对象并将其存储为裸 ptr。

我是 C++ 开发的新手，所以，我的问题是根据我听到的一般建议提出的：

尽可能避免使用原始指针

1. 在这种情况下，是否可以使用裸 ptr 来存储 Foo 不拥有的 tool_box 对象？或者我可以使用 smart_ptr 做得更好吗？
2. 将 ptr 从 FooFactory 类传递到 ToolBox 到每个新对象的模式是正确的还是我可以做的更好？

我的类的伪代码：

class FooFactory {
 public:
  FooFactory() {
    tool_box_.reset(new ToolBox());
  }

  std::unique_ptr<Foo> NewFoo() {
    std::unique_ptr<Foo> foo(new Foo(tool_box_.get());
    return foo;
  }
  std::unique_ptr<ToolBox> tool_box_;
}

class Foo {
 public:
  Foo(ToolBox* tool_box) {
    tool_box_ = tool_box;
  }
 private:
  // Not Owned
  ToolBox* tool_box;
}

Answer 1

factory 通常永远不会控制对象的生命周期。它应该分发一个适当的指针，最好是std::unique_ptr，调用者确定它的生命周期。

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

class Box
{
public:
    Box() {}
};

class Foo
{
public:
    Foo(std::shared_ptr<Box> &box)
    : m_box(box)
    {
    }
    virtual ~Foo(){}

    void print()
    {
        std::cout << "Hello World" << std::endl;
    }

protected:
    Box *getBox()
    {
        return m_box.get();
    }

private:
    std::shared_ptr<Box> m_box;
};

class FooFactory
{
public:
    FooFactory()
    {
        m_box = std:make_shared<Box>();
    }

    std::unique_ptr<Foo> CreateFoo()
    {
        return std::make_unique<Foo>(m_box);
    }

private:
    std::shared_ptr<Box> m_box;
};

int main()
{
    FooFactory factory;
    std::unique_ptr<Foo> foo = factory.CreateFoo();

    foo->print();

    return 0;
}

Answer 2

将非拥有“指针”存储到对象（同时将类与该对象耦合）的一种方法是存储引用（或者可能是 const 引用）而不是指针。

根据我的经验，需要使用该引用初始化类的限制有助于分层设计并简化生命周期管理。