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

Question

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

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

avoid raw pointers when possible

在这种情况下，使用 bare ptr 来存储 Foo 不拥有的 tool_box 对象是否正常？或者我可以使用 smart_ptr 做得更好吗？
从 FooFactory class 将 ptr 传递到 ToolBox 到每个新对象的模式是否正确，或者我能做些什么更好的事情吗？

我的 classes 的伪代码：

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

A 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

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

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

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

How to store pointers to objects that class doesn't own?

c++

pointers

smart-pointers