智能指针 shared_ptr

shared_ptr.h

template <class T>
class Shared_ptr
{
    typedef int countType;
public:
    Shared_ptr()
        :ptr(0)
        ,count(0)
    {
    }
    Shared_ptr(T* p)
        :ptr(p)
        ,count(0)
    {
        count = new countType(1);
    }

    Shared_ptr(const Shared_ptr& p)
        :ptr(p.ptr)
        ,count(p.count)
    {
        ++(*count);
    }

    Shared_ptr& operator=(const Shared_ptr& p)
    {
        if(this == &p) return *this;

        free();

        ptr = p.ptr;
        count = p.count;
        ++(*count);

        return *this;
    }

    ~Shared_ptr()
    {
        free();
    }

    T& operator*() const
    {
        //assert
        return *ptr;
    }

    T* operator->()const
    {
        return ptr;
    }

    T* get() const
    {
        return ptr;
    }

    int getCount() const
    {
        return *count;
    }


private:
    void free()
    {
        if(*count == 0) return;

        --(*count);

        if(*count == 0)
        {
            if(ptr)
            {
                delete ptr;
                ptr = 0;
            }

            if(count)
            {
                delete count;
                count = 0;
            }
        }
    }

private:
    T* ptr;
    countType* count;
};

test.cpp

#include "shared_ptr.h"
#include <crtdbg.h>
#include <iostream>

#ifdef _DEBUG

#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)

#endif



class TestClass
{
public:
    TestClass()
        :X(0)
        ,Y(0)
    {
    }
    TestClass(int x, int y)
        :X(x)
        ,Y(y)
    {
    }
    ~TestClass(){}

private:
    int X;
    int Y;
};

void test()
{
    Shared_ptr<TestClass> testClassPtr(new TestClass(3, 2));
    Shared_ptr<TestClass> testClassPtr1(testClassPtr);
    std::cout << "count1: " << testClassPtr1.getCount()<< std::endl;

    Shared_ptr<TestClass> testClassPtr2(new TestClass(4, 5));
    Shared_ptr<TestClass> testClassPtr3(testClassPtr2);

    std::cout << "count2: " << testClassPtr2.getCount() << std::endl;

    testClassPtr3 = testClassPtr;
    std::cout << "count1: " << testClassPtr1.getCount()<< std::endl;
    std::cout << "count2: " << testClassPtr2.getCount() << std::endl;


}

int main()
{

    test();

    _CrtDumpMemoryLeaks();

    system("pause");

    return 0;
}