Question

我有一个如下课程：

class A {
  SuperHugeClass* s;
public:
  A(){ s = new SuperHugeClass(); }
};

因为SuperHugeClass需要大量内存，所以我可以使用默认构造函数和赋值运算符提供的浅复制。但是，我也不想泄漏内存，所以我需要delete s，但我必须小心，否则我会多次删除它。

这样做的一种方法是按如下方式引用s：

class A {
  int* refcount;
  SuperHugeClass* s;

public:
  A(){
    refcount = new int(1);
    s = new SuperHugeClass();
  }

  A(const A& other) : refcount(other.refcount), s(other.s) {
    (*refcount)++;
  }

  ~A() {
     (*refcount)--;
     if (!(*refcount)) {
       delete refcount;
       delete s;
     }
   }

  friend void swap(const A& a, const A& aa) {
    std::swap(a.refcount, aa.refcount);
    std::swap(a.s, aa.s);
  }

  A& operator=(A other) {
    swap(*this, other);
    return (*this);
  }
};

这是我第一次需要做这样的事情，但在我看来，这应该是非常标准的，所以应该有一个'规范'的解决方案。有没有其他方法可以做到这一点？谢谢！

Answer 1

使用std :: shared_ptr

class A {
  std::shared_ptr<SuperHugeClass> s;
public:
  A()
  : s(new SuperHugeClass())
  {
  }
};

就是这样。默认生成的复制构造函数/赋值运算符/析构函数可以满足您的需要。

Answer 2

使用std/boost::shared_ptr代替您的重新计数指针。

使用共享指针释放类中的资源

2 个答案: