在对象之间拥有或共享资源

Question

A 有一组具有以下类型的工作对象：

template<class T> struct Worker;

不同的工人，有不同的模板参数T，使用一些资源

struct Resource;

不同Workers 使用的Resources 都具有相同的类型但可能有不同的值。资源通常很重，应避免不必要的副本。资源仅供工作人员使用，有些是专门使用的，有些是在他们之间共享的（此信息在编译时可用）。如果一个资源被独占使用，我希望 Worker 成为（可能，有效地）它的所有者，否则它应该存储一个引用。在伪代码中，我想做任何一个

Resource resource1(...);
Worker<Type1> worker1(..., std::move(resource1));
// worker1 owns resource1

Resource resource2(...);
Worker<Type2> worker2(..., std::move(resource2));
// worker2 owns resource2

或

Resource resource(...);
Worker<Type1> worker1(..., resource);
Worker<Type2> worker2(..., resource);
// workers use resource, but do not own it

我看到了两种直接的方法：

1. 使用模板参数来确定Worker 中代表资源的数据成员的类型：

   template<class T, class R>
   struct Worker
   {
       Worker(T arg, R resource) :
           resource_(std::forward<R>(resource))
       { }  
   
       R resource_;
   };
   
   template<class T, class R>
   Worker(T arg, R&& resource) -> Worker<T, R>;
   
   void foo()
   {
       Resource r;
   
       Worker worker1(0, r);
       Worker worker2(0, r);
       // type of worker1.resource_ is Resource&,
       // type of worker2.resource_ is Resource&,
       // both store a reference to r
   
       Worker worker3(0, Resource{});
       // type of worker3.resource_ is Resource,
       // Resource{} is moved into it
   }
   

2. 使用std::shared_ptr:

   template<class T>
   struct Worker
   {
       Worker(T arg, const std::shared_ptr<Resource>& resource) :
           resource_(resource)
       { }
   
       template<class R, typename = std::enable_if_t<std::is_same_v<R, Resource>>>
       Worker(T arg, R&& resource) :
           resource_(std::make_shared<Resource>(std::move(resource)))
       { }
   
       std::shared_ptr<Resource> resource_;
   };
   
   void foo()
   {
       auto resource = std::make_shared<Resource>();
   
       Worker worker1(0, resource);
       Worker worker2(0, resource);
       // worker1 and worker2 share *resource_
   
       Worker worker3(0, Resource{});
       // worker3 effectively owns *resource_
   }
   

这些方法显然非常不同，但在当前情况下实际上是等效的。我都不喜欢他们俩。

在第一种情况下，我不喜欢资源存储在Workers 之外的某个局部变量中。在Worker 中获得悬空引用存在潜在风险。

在第二种情况下，在创建了所有 Workers 之后，不必要的计数引用仍保留在 resource 中。我可以按值获取shared_ptr 并在最后一个Worker 构造中使用std::move，但这需要我显式跟踪最后一个构造函数——这是一个很好的解决错误的方法。

这些问题不会影响代码的正确性，但可能意味着整个设计存在缺陷。我认为应该有更好的方法。请解释在这种情况下的最佳做法是什么。 （我知道我的问题可能过于笼统，我需要的解决方案可能取决于我创建资源和工人的确切方式；好的解决方案可能来自对问题的不同看法，目前我陷入了两种方法我在上面概述了。）

Full code here.

Answer 1

在第二种情况下，不必要的计数引用保留在资源中 在创建了所有工人之后。我可以按价值接受shared_ptr 并在最后一个 Worker 构造中使用std::move，但它会 要求我显式跟踪最后一个构造函数 - 一个很好的方法 得到一个错误。

不，你没有；默认情况下使用unique_ptr 创建您的资源，在需要时将其转换为shared_ptr 的成本“零”。

---

考虑只使用一个接受std::shared_ptr的构造函数按值; std::shared_ptr 有一个构造函数，它采用 rvalue std::unique_ptr;

template<class T>
struct Worker
{
    Worker(T arg, std::shared_ptr<Resource> resource) :
        resource_(std::move(resource))
    { }

    std::shared_ptr<Resource> resource_;
};

void foo()
{
    auto resource = std::make_unique<Resource>();
    auto resource_shared = std::make_shared<Resource>();

    Worker worker1(0, std::move(resource));
    Worker worker2(0, resource_shared);
    Worker worker3(0, resource_shared);
    // worker2 and worker3 share *shared_resource


    Worker worker4(0, std::move(resource));  //resource is empty
}

Live Demo