在共享指针中捕获内存泄漏？

Question

Title pretty much says it all, I'm almost positive it's either in the copy constructor or the assignment operator, and I'm pretty sure it's the latter. It's a pretty short class, so I'll post the entire thing, any advice on how to handle it would be good. I'm honestly a bit over my head here too, so any pointing to some solid reading would be greatly appreciated.

#pragma once

//for non-learning purposes, boost has a good smart pointer
template <class type>
class sPtr
{
private:
    type *p;
    int r; //referenceCount

    void add()
    {
        r++;
    }
    int release()
    {
        return --r;
    }
public:
    sPtr(): p(NULL), r(1) {}
    sPtr(type *pValue): p(pValue)
    {
        add();
    }
    sPtr(const sPtr<type> & sp): p(sp.p), r(sp.r)
    {
        add();
    }
    ~sPtr()
    {
        if(release() == 0)
        {
            delete p;
        }
    }

    type* get()
    {
        return p;
    }

    type& operator*()
    {
        return *p;
    }
    type* operator->()
    {
        return p;
    }
    sPtr<type>& operator=(sPtr<type> sp)
    {
        std::swap(this->p, sp.p);
        std::swap(this->r, sp.r);
        add();

        return *this;
    }
};

I'm pretty sure that the assignment operator should be passed by reference, but I'm not sure on how this will affect the implementation. I tried a few different implementations and all of them still had the leak.

Answer 1

Each of your shared pointers keeps track of its own separate reference count. This is obviously no good. When one is destroyed, the ref count on the others is not updated. You need to keep the reference count in a separate location that all the shared pointers have access to.

Answer 2

In addition to what Ben already mentioned, you are starting your reference count at 1 in your default constructor (and not initializing it at all in your others). If you assign a pointer to it after the default constructor, your reference count would be 2, and when you call release, back to 1. In short, the only time your reference count would be 0 (indicating you can delete the object) is if you call release 1 more time than add was called. Typically, you want those calls to be symmetrical (call to add corresponds to call to release).