将 shared_ptr 与 const 引用一起使用

Question

我需要创建几个Worker 类，这些类具有指向主程序拥有的Object 的指针。这是在 C++14 中

出于某种原因，Object 必须满足某些条件 - 它必须有一个已删除的默认构造函数，它的不可复制、不可移动。我需要使用智能指针。

主程序将拥有Object。每个工人阶级都需要从中读取东西

class Object
{
  Object() = delete;
  ~Object();

  // Non copyable
  Object(const Object &other) = delete;
  Object &operator=(const Object &other) = delete;

  // Non movable
  Object(Object &&other) = delete;
  Object &operator=(Object &&other) = delete;

  // Constructor
  explicit Object(double threshold);
};

class Worker
{
public:
  void initialize(const Object& obj)
  {
    // Option 1 - errors out, complains its non copyable
    object_ptr = std::make_shared<const Object>(obj);

    // Option 2
    object_ptr = std::shared_ptr<const Object>(&obj);

    // Option 3
    object_ptr = std::shared_ptr<const Object>(&obj, [](const Object*){});
  }

  void doSomething();

private:
  std::shared_ptr<const Object> object_ptr;
};

int main () 
{
  Object object;

  Worker worker1;
  Worker worker2;

  worker1.initialize(object);
  worker2.initialize(object);

  while(1)
  {
    // Main does stuff to Object

    worker1.doSomething();
    worker2.doSomething();
  }

  return 0;
}

在Worker 中初始化指针的最佳方法是什么？

Answer 1

我个人会这样做

class Worker
{
public:
    void initialize(const Object& obj)
    {
        object_ptr = &obj;
    }
private:
    const Object* object_ptr = nullptr;
};

原始指针表示非所有权，情况正是如此。

如果您必须使用shared_ptr，则无法将其作为参数传入，shared_ptr 与其关联的数据不仅仅是托管对象。

class Worker
{
public:
    void initialize(std::shared_ptr<const Object> p)
    {
        swap(object_ptr, p);
    }
private:
    std::shared_ptr<const Object> object_ptr;
};

int main()
{
    auto obj = std::make_shared<const Object>();
    //...
}

shared_ptr 的意思正是它所说的：资源是共享的。传递shared_ptr 就是声明有多个所有者，并且资源对所有人都是通用的，即资源必须比其中任何一个都长。

请注意您是如何将对象 在堆栈中（或者更确切地说，具有自动存储持续时间），这表明该资源实际上不属于工作人员。根据工人的定义，我们自动知道该对象将比工人更长寿，这远远优于使用shared_ptrs。

Answer 2

为什么不使用 shared_ptr 的aliasing constructor。

template< class Y > 
shared_ptr( const shared_ptr<Y>& r, element_type* ptr ) noexcept; 

这允许您创建一个 shared_ptr，但实际上并不拥有该对象，因此存储的值实际上不被引用计数。这意味着引用的对象必须在外部保持有效。

在这种情况下，只需将初始化设置为：

void initialize(const Object& obj)
  {
    typedef std::shared_ptr<const Object> my_ptr;
    object_ptr = my_ptr(my_ptr(), &obj);
  }

这是一个 hack，它会伪造一个真正的 shared_ptr，但它会起作用。对于一个独立的外部示例，请尝试：

#include <memory>

struct x_t
{
    x_t() = delete;
    x_t(const x_t&) = delete;
    x_t(x_t&&) = delete;
    x_t(double y) {}
};

int main()
{
    typedef std::shared_ptr<const x_t> x_t_ptr;
    const x_t x(5);

    x_t_ptr ptr = x_t_ptr(x_t_ptr(), &x);

    return 0;
}

我真的应该警告你，你不应该这样做，因为当你没有这样的东西时，你似乎有记忆安全。基本上，您要保证您有内存安全，然后有效地使用指向临时对象的原始指针。这是非常危险的。