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

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

我正在尝试编写两个类 FooFactory 和 Foo。 FooFactory 在构造函数中初始化一个对象 ToolBox 并将其存储在 unique_ptr 中，因为我希望在工厂被破坏后清理它。 Foo 的所有实例都应该能够使用 ToolBox，所以我将 ptr 传递给 Foo 构造函数中的 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;
}

解决方法

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

,

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

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