smartptr.h

本人自己的作品

#ifndef _HUTIAN_CSMARTPTR_
#define _HUTIAN_CSMARTPTR_
#pragma once
#ifndef __ATLBASE_H__
	#include <atlbase.h>
#endif
/**
类名：CSmartPtr<T> CSmartPtr2<T>
作用：带引用计数的智能指针,CSmartPtr是单个对象，CSmartPtr2是数组
作者：老牛胡天
时间：2005年7月2日（写注释时间，写代码时间忘了）
特别说明：可以任意使用
*/
///单个对象的带引用计数的智能指针
template<class T> class CSmartPtr
{
protected:
	///实际内存
	T*   _data;
	///使用量记数
	long* _user;
public:
	///构造一个空的智能指针对象,必须用New()的调用分配内存,方可使用
	CSmartPtr()
	{
		_data = NULL;
		_user = NULL;
	}
	~CSmartPtr()
	{
		Destory();
	}
	///复制构造,和复制的对象共用内存,并未分配新内存
	CSmartPtr(const CSmartPtr<T>& ts)
		: _data(ts._data)
		, _user(ts._user)
	{
		if(_user)
			(*_user) += 1;
	}
	///实际分配内存
	bool New()
	{
		Destory();
		_data  = new T;
		ATLASSERT(_data);
		_user  = new long;
		ATLASSERT(_user);
		*_user = 1;
		return _data != NULL;
	}
	///减少引用记数，如为0，销毁内存
	void Destory()
	{
		if(_user)
		{
			ATLASSERT(_data);
			(*_user)  -= 1;
			if(*_user == 0)
			{
				delete _user;
				delete (T*)_data;
			}
			_user = NULL;
			_data = NULL;
		}
	}
	///从另一个对象中得到内存--共用
	const CSmartPtr<T>& operator = (const CSmartPtr<T>& ts)
	{
		if(&ts == this)
			return *this;
		Destory();
		_data = ts._data;
		_user = ts._user;
		if(_user)
			(*_user) += 1;
		return *this;
	}
	///数据比较
	bool operator == (const CSmartPtr<T>& ts) const
	{
		return _data == ts._data;
	}
	///只读引用内部指针
	T& operator *() const
	{
		return *_data;
	}
	///重载以按一般指针方式使用
	T* operator->() const
	{
		return _data;
	}
	///是否真正有内存
	operator bool() const
	{
		return _data == NULL ? false : true;
	}
};

///数组对象的带引用计数的智能指针
template<class T>
class CSmartPtr2
{
protected:
	///数组大小
	int	 _size;
	///使用的内存
	T*   _data;
	///使用计数
	long* _user;
public:
	///构造一个空的智能指针对象,必须用New()的调用分配内存,方可使用
	CSmartPtr2()
	{
		_data = NULL;
		_user = NULL;
		_size = 0;
	}
	///复制构造,和复制的对象共用内存,并未分配新内存
	CSmartPtr2(const CSmartPtr2<T>& ts)
		: _data(ts._data)
		, _user(ts._user)
		, _size(ts._size)
	{
		if(_user)
			(*_user) += 1;
	}
	///从已分配的内存构造一个对象
	CSmartPtr2(LPVOID data,int size)
	{
		_data  = (T*)data;
		_user  = new long;
		*_user = 1;
		_size = size;
	}
	///实际分配内存
	bool New(int size)
	{
		Destory();
		_data  = new T[size];
		_user  = new long;
		*_user = 1;
		_size = size;
		return _data != NULL;
	}
	~CSmartPtr2()
	{
		Destory();
	}
	///减少引用记数，如为0，销毁内存
	void Destory()
	{
		if(_user)
		{
			ATLASSERT(_data);
			(*_user)  -= 1;
			if(*_user <= 0)
			{
				delete _user;
				delete _data;
			}
			_user = NULL;
			_data = NULL;
			_size = 0;
		}
	}
	///从另一个对象中得到内存--共用
	const CSmartPtr2<T>& operator = (const CSmartPtr2<T>& ts)
	{
		if(&ts == this)
			return *this;
		Destory();
		_data = ts._data;
		_user = ts._user;
		_size = ts._size;
		if(_user)
			(*_user) += 1;
		return *this;
	}
	///是否指向同一个对象
	bool operator == (const CSmartPtr2<T>& ts) const
	{
		return _data == ts._data;
	}
	///重载[],以方便正常方式使用数组
	T& operator[](int a)
	{
		return _data[a];
	}
	///取内存出来使用
	T* Data()
	{
		return _data;
	}
	///取内存出来使用--作为一般指针
	LPVOID Memory()
	{
		return (LPVOID)_data;
	}
	///正确解析内存地址
	T* operator *()
	{
		return _data;
	}
	///从已分配的内存重新构造对象
	void ptrtoSmart(LPVOID data,int size)
	{
		Destory();
		_data  = (T*)data;
		_user  = new long;
		*_user = 1;
		_size = size;
	}
	///数组大小
	int size()
	{
		return _size;
	}
	///单独取出内存
	T* Detach()
	{
		ATLASSERT(*_user == 1);
		if(*_user > 1)
			return NULL;///多人使用
		T* data  = _data;
		_data = NULL;
		delete _user;
		_user = NULL;
		return data;
	}
	///指针是否可为空
	operator bool() const
	{
		return _data == NULL ? false : true;
	}
};
#endif