用于堆分配的对象的设置器

Setters for heap-allocated objects

本文关键字：设置 对象 用于 分配      更新时间：2023-10-16

建议有一个由分配在堆中的对象组成的类。

class A
{
public:
    A() { m_b = new B; m_c = new C; }
    virtual ~A() { delete m_b; delete m_c; }
    inline B* b() const { return m_b; }
    inline C* c() const { return m_c; }
private:
    B* m_b;
    C* m_c;
}

哪些播放器对于此类代码来说是最好的？

我想出了这个，

inline void setB(B* b) const { delete m_b; m_b = b; }
inline void setC(C* c) const { delete m_c; m_c = c; }

但是有一个问题。如果我们添加了一个非主型变量或仅一个变量，则不必使用此设置器删除，它将在下一个设置器的下一次调用后将其删除，并且这种情况将导致错误或意外行为。

我们无法直接删除对象，因为Getters具有const修饰符。此外，这是不安全的，因为类的用户可能不知道内部对象是否分配在堆中。

您能解释一下我如何将固定器与堆分配的对象使用？

不要使用RAW new和delete。改用智能指针 - 它们更安全，更易于使用。就您而言，std::unique_ptr看起来像个好候选人：

class A
{
public:
    A() : m_b{std::make_unique<B>()}, m_c{std::make_unique<C>()} { }
    virtual ~A() = default;
    inline B* b() const { return m_b.get(); }
    inline C* c() const { return m_c.get(); }
private:
    std::unique_ptr<B> m_b;
    std::unique_ptr<C> m_c;
}

您的设定器可以简单地为：

void setB(std::unique_ptr<B>&& b) { m_b = std::move(b); }
void setC(std::unique_ptr<C>&& c) { m_c = std::move(c); }

遵循0。

的规则 
class A {
public:
  A()=default;
  virtual ~A() = default;
  B* b() const { return m_b.get(); }
  C* c() const { return m_c.get(); }
  void set_b(std::unique_ptr<B> in){m_b=std::move(in);}
  void set_c(std::unique_ptr<C> in){m_c=std::move(in);}
private:
  std::unique_ptr<B> m_b=std::make_unique<B>();
  std::unique_ptr<C> m_c=std::make_unique<C>();
};

唯一的PTR都可以清楚所有权，修复了您不知道的错误，并使您的代码不那么脆弱。

错误的错误：

  1. 在您的原始代码中，如果new C投掷，您将泄漏B。

  2. 如果您复制或移动原始对象，则它们会双重删除

如果您想混合拥有和不拥有的亚物体，第一件事就是不要这样做。第二个是使用更奇特的智能指针。但是类型应该具有清晰的所有权语义，并且"也许不是自己"是代码的气味，并且会引起错误。

相关文章：