将资源锁定对象作为参数传递

Question

将对象作为参数传递的好方法是什么？在我的代码中，我一直使用引用而不是指针，如果可能的话，我想坚持这种方法。但是，有一种情况无法正常工作：

class Resource {
    Resource(...) { //expensive resource initialization }
    ~Resource() { //destroy resource }
};

class User {
    User(const Resource & res) : res_(res) { //initialize user }
private:
    Resource res_;
}

void Init() {
    Resource res(...);
    User user = new User(res);
} //res is destroyed - along with its associated resource
//user can no longer use the resource

在这种情况下是否应该使用任何最佳实践？我想要实现的结果是当User对象被销毁时自动销毁Resource，而不是依赖User对象来创建资源本身。我的感觉是我应该重载 Resource 的复制构造函数。还有其他想法吗？

Answer 1

最好的办法是在 User 类中保留一个 shared_ptr 成员。但这需要在空闲（堆）内存上生成资源。

class User {
  User(Resource * res) : res_ptr(res) { //initialize user }
private:
  shared_ptr<Resource> res_ptr;
}

void Init() {
  Resource * res = new Resource(...);
  User user = new User(res);
} 

第二种方法是为Resource提供一个假的复制构造函数和交换机制。

class Resource
{
private:
  explicit Resource(const Resource &); // disabled to avoid heavy copy.
  const Resource & operator = (const Resource & );
  int * int_res;
public:
  Resource() : int_res(new int(100)) { } 

  ~Resource()
  {
    if(int_res != NULL)
      delete int_res;
  }

  Resource(Resource & other) : int_res(NULL) 
  {
    this->swap(other);
  }

  void swap(Resource & other)
  {
    using std::swap;
    swap(int_res, other.int_res);
  }
};

class User
{
private:
  Resource resource;
  User();
  User(const User &);
  const User & operator = (const User &);
public:
  User(Resource & res) : resource(res) {  }
  ~User() { }
};

但这是危险且容易出错的，因为创建用户后，您会将资源置于僵尸状态。对于这段代码，所有对分配给NULL的int_res指针的访问都会给你带来访问冲突错误。

我可以解释的最后一种方法是使用 C++0x 功能“移动语义”。

class Resource
{
// ...
// ...
  // Replace with Resource(Resource & other)
  Resource(Resource && other) : int_res(NULL) //Move constructor
  {
    this->swap(other);
  }

  const Resource & operator = (Resource && other) // Move assignment operator
  {
      this->swap(other);
      return *this;
  }

  void swap(Resource & other)
  {
    using std::swap;
    swap(int_res, other.int_res);
  }
};

class User
{
private:
  Resource resource;
  User();
  User(const User &);
  const User & operator = (const User &);
public:
  User(Resource && res) : resource(std::move(res)) {  }
  ~User() { }
};

void Init() {
    Resource res(...);
    User user = new User(std::move(res));
}

这种方法比较安全一些。您不必处理指针，如果您忘记编写 std::move，您将收到编译器错误，指出“您无法将 Resource 实例绑定到 < code>Resource&&”或“Resource 的复制构造函数已禁用。”

&& 强调该对象是暂时的并且即将消失。所以这种方式更适合Resource由函数生成并返回的场景。如果我是你，我会将构造函数设为私有并使用友元函数生成它。

Resource GetResource(....)
{
  Resource res(...);
  return res;
}

void Init() 
{     
  User user = new User( GetResource(...) );
}

这段代码在“移动语义”下表现完美。如果您能够编写 C++0x 代码，则必须学习它。 此和这是两个很好的视频。