仿照shared_ptr写的一种智能指针（共享型的智能指针)

    智能指针可以解决内存泄露的问题，就是用对象来管理内存资源。由于C++机制中有对象在离开作用域的时候，析构函数会被自动调用。此时在析构函数中完成动态申请内存的释放。程序员在使用智能指针后。不用担心内存泄露。当然互引用的情况，还是会造成内存泄露，即使使用本文中所编写的智能指针。

    由于C++没有垃圾回收机制，但是可以利用析构函数自调用的机制来实现指针的自释放。通过类来包装一个指针和该指针所指向内存的引用计数器。当大于1个以上的指针指向同一内存区域时，要释放该区域的时候，先判断该区域的引用计数是否为1，若不为1，则不释放，只是把该区域的引用计数减1.当减小到1的时候，才真正的去delete掉动态申请的那块区域。

    在智能指针中，主要目的是解决内存泄露的问题。但是由于智能指针在浅拷贝(即只是把指针赋值，而不是申请一块与源对象的内存区域一样的内存）的时候，存在多个指针同时指向一块内存区域的情况，所以需要显示定义智能指针类的拷贝构造函数和赋值构造函数，并在里面处理真正的指针赋值和引用计数的变化。

 

源代码如下：

#include <stdio.h>
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>


template <typename T>
class SharedSmartPtr
{
private:
	T* m_ptr;
	unsigned int m_count;
public:
	SharedSmartPtr(T* p):m_ptr(p),m_count(1){}
	~SharedSmartPtr()
	{
		Destructor();

	}
	void Destructor()
	{
		if(m_count==1)
		{ 
			delete m_ptr;
		}
		m_count--;
	}
	T& operator*()
	{
		return *m_ptr;
	}
	T* operator->()
	{
		return m_ptr;
	}
	//拷贝构造函数
	SharedSmartPtr(SharedSmartPtr &SSP):m_ptr(SSP.m_ptr),m_count(SSP.m_count)
	{
		m_count++;

	}
	//赋值构造函数
	SharedSmartPtr& operator =(SharedSmartPtr &SPP)
	{
		Destructor();
		m_ptr=SPP.m_ptr;
		m_count=SPP.m_count;
		m_count++;
		return *this;
	}
};

class Investment
{
public:
	int price;
	Investment(int p)
	{
		price=p;
	}
};



void main()
{
	/***********用于检测内存泄露**************/
	int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
	tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
   _CrtSetDbgFlag( tmpFlag );
   /*************用于检测内存泄露********************/

	SharedSmartPtr<Investment> ssp(new Investment(2));
    SharedSmartPtr<Investment>  ssp2(ssp);

	ssp2->price=5;
	printf("ssp->price=%d\n",ssp->price);

	SharedSmartPtr<Investment> ssp3=ssp2;

	SharedSmartPtr<Investment> sspx(new Investment(10));
	sspx=ssp;

	printf("sspx->price=%d\n",sspx->price);

	system("PAUSE");
}