Question

I have a class like the following:

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

Because SuperHugeClass takes a lot of memory, I’m fine with the shallow copying provided by the default constructor and assignment operator. However, I also don’t want to leak memory, so I need to delete s, but I have to be careful about it because otherwise I’ll delete it more than once.

One way of doing this is by refcounting s as follows:

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);
  }
}; 

This is the first time I’ve needed to do something like this, but it seems to me that this should be pretty standard and so there should be a ‘canonical’ solution. Are there any other ways of doing this? Thanks!

Answer 1

Use std::shared_ptr

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

and thats it. Default generated copy constructor/assignment operator/destructor do just what you need.