Question

当前实施

我有一个包含unique_ptr字段的类，这些字段依赖于另一个：

class ResourceManager {
  ResourceManager() {}

  ResourceManager(A* a_ptr) :
    b_ptr(new B(a)),
    c_ptr(new C(b_ptr.get())) {}

  ResourceManager& operator=(ResourceManager&& that) {
    // Call destructor, then construct a new instance on top
    ~ResourceManager();
    ResourceManager* new_this = new(this) ResourceManager();

    // Surely this must be the case, right?
    // Is there any reason to prefer using either?
    assert(new_this == this);

    new_this->b_ptr = that.b_ptr;
    new_this->c_ptr = that.c_ptr;

    return *new_this;
  }

  unique_ptr<B> b;
  unique_ptr<C> c;
};

用例

这里的用例是我想将新值重新分配给指针，同时将ResourceManager保持为堆栈分配变量，或者作为非指针类成员。

根据我目前的设置，我想像是这样使用它：

A a, another_a;
ResourceManager r(&a);

// Use r...

// Destroy old ResourceManager and create the new one in place.
r = ResourceManager(&another_a);

这甚至是一个问题的原因是由于B和C不可分配（例如文件流）

丑陋的替代

另一种丑陋（和危险）的方法是明确地reset unique_ptr字段关键地以相反的顺序（请记住，C依赖于B，因此必须是首先破坏，有效地模仿默认的破坏行为。

ResourceManager& operator=(ResourceManager&& that) {
  // Mimic destructor call (reverse-order destruction)
  c_ptr.reset();
  b_ptr.reset();

  b_ptr = that.b_ptr;
  c_ptr = that.c_ptr;

  return *this;    
}

请注意，错误的实现只是使用ResourceManager的默认赋值运算符。这将分配字段 in-order ，这意味着有序销毁unique_ptr，而我们需要逆序销毁。

问题

this指针与展示位置new和显式析构函数调用的使用是否安全？

我必须使用返回的new_this指针而不是原始的this指针（例如，如果this指针在调用析构函数后在技术上失效了吗？）

有没有更好的建议方法来实现这一目标？如果在类中添加更多此类unique_ptr字段，我必须确保将副本添加到赋值运算符。例如，是否可以调用移动构造函数，如下所示：

ResourceManager& operator=(ResourceManager&& that) {
  // Call destructor
  ~ResourceManager();

  // Move-construct a new instance on top
  ResourceManager* new_this = new(this) ResourceManager(that);
  return *new_this;
}

Answer 1

您的解决方案似乎过于复杂。

我会像这样编码：

class ResourceManager {
  ResourceManager() {}

  ResourceManager(A* a_ptr) :
    b_ptr(new B(a)),
    c_ptr(new C(b_ptr.get())) {}

  ResourceManager& operator=(ResourceManager&& that) 
  {
    // the order of these moves/assignments is important
    // The old value of *(this->c_ptr) will be destroyed before
    // the old value of *(this->b_ptr) which is good because *c_ptr presumably
    // has an unprotected pointer to *b_ptr.
    c_ptr = std::move(that.c_ptr);
    b_ptr = std::move(that.b_ptr);
    //  (a better solution might be to use shared_ptr<B> rather than unique_ptr<B> 
    return *this;
  }

  unique_ptr<B> b_ptr;
  unique_ptr<C> c_ptr;
};

注意：当移动分配返回时，that将＆＃34;清空＆＃34;意味着that.b_ptr和that.c_ptr都是nullptr。这是移动分配的预期结果。

或者如果＆＃34;重建＆＃34;赋值的目标很重要（假设这个例子中没有显示额外的代码就是这样）我可能会添加一个移动构造函数和一个交换方法，如下所示：

 ResourceManager(ResourceManager&& that)
 : b_ptr(std::move(that.b_ptr)),
   c_ptr(std::move(that.c_ptr))    
 {
 }

 void swap(ResourceManager & that)
 {
   b_ptr.swap(that.b_ptr);
   c_ptr.swap(that.c_ptr);  
 }

 ResourceManager& operator=(ResourceManager&& that) 
 {
     ResourceManager temp(std::move(that));
     this->swap(temp);
     return *this;
 }

使用新版本是否安全＆＃39;这个＆＃39;指针

当前实施

用例

丑陋的替代

问题

1 个答案: