灵巧指针与垃圾回收源代码CPtrArray
http://www.chinaaspx.com/archive/VC/7043.htm
本人将源代码粘贴于此，各位有兴趣的网友可以测试一试。
说明：
只要将两个文件加入到你的工程中，并在你的CWinApp派生类中加入如下一句即可：
CPtrManager thePtrManager；
然后，在使用普通指针的地方，用灵巧指针替换即可，假如有一个类test，并有如下应用：
test * ptest=new test;
other code
delete ptest;
现在可这样应用：
auto_ptr<test> ptest= new test;
other code
再不用人为的delete ptest 了，垃圾回收将自动清除，即使你有如下应用：
auto_ptr<test> ptest;
test mytest;
ptest=&mytest;
你也不用担心，灵巧指针也不会误删你在栈中的内存。
只要大家认真帮我测试这段代码到没有 BUG，并对部分算法进行优化和改进，那么，我可以相信：“C++中无垃圾回收”将成为历史。
// PtrManager.h: interface for the CPtrManager class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_PTRMANAGER_H__BB4B38B5_DA34_11D3_9327_000629377185__INCLUDED_)
#define AFX_PTRMANAGER_H__BB4B38B5_DA34_11D3_9327_000629377185__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Afxmt.h"
class CMySingleLock:public CSingleLock
{
public:
CMySingleLock(CSyncObject* pObject, BOOL bInitialLock = FALSE )
:CSingleLock(pObject,bInitialLock){}
void operator delete(void * p)
{
free(p);
}
void * operator new(size_t size)
{
return malloc(size);
}
};
class CPtr
{
friend class CMark;
public:
int GetPtrSize();
CMutex * GetCMutex();
void * GetPtr();
CPtr();
virtual ~CPtr();
int GetCount();
void AddAutoPtr(void * autoPtr,int AutoMark);
BOOL DeleteAutoPtr(void * autoPtr);
void SetPtr(void * thePtr,int Size,
int mark,int count=0);
void operator delete(void * p)
{
free(p);
}
void * operator new(size_t size)
{
return malloc(size);
}
private:
int m_mark;
int m_count;
void * m_ptr;
int m_size;
CPtrArray AutoPtrArray;
CUIntArray m_AutoMark; file://0 in the stack; >0 =mark
CMutex mutex;
};
class CMark
{
friend class CMarkTable;
public:
CMark(){}
virtual ~CMark(){}
void operator delete(void * p)
{
free(p);
}
void * operator new(size_t size)
{
return malloc(size);
}
void CopyFromCPtr(CPtr* theCPtr);
BOOL bIsNoneInStack();
void Release();
private:
int m_mark;
CPtrArray autoptrArray;
CUIntArray automarkArray;
};
class CMarkTable
{
public:
CMarkTable(){Init();}
virtual ~CMarkTable(){}
void AddCMark(CMark * theCMark);
BOOL FindMark(int mark);
void Init();
void DoLockMark();
private:
CPtrArray CMarkArray;
CPtrArray CLockMarkArray;
void GetLockMark();
BOOL FindLockMark(int mark);
void RemoveUnlockMark();
void RemoveGroup(int automark);
};
class CPtrManager
{
public:
int GetAutoMark(void * ptr);
CPtrManager();
virtual ~CPtrManager();
int GetMarkFromPtr(void * Ptr);
void *MallocPtr(size_t size);
BOOL bCanWrite();
void DeletePtr(int mark,void * Ptr);
void AddPtr(void *Ptr,int PtrSize);
static CPtrManager * GetPtrManager();
CPtr * GetCPtr(void * Ptr,int mark);
private:
CPtrArray m_ptr;
void* pCurrent;
unsigned int m_mark;
CUIntArray m_removed;
BOOL bWrite;
static CPtrManager * p_this;
CMutex mutex;
CMarkTable myMarkTable;
void RemoveLockRes();
void CopyAllMark();
static UINT myThreadProc(LPVOID lparm);
CWinThread* myThread;
void BeginThread()
{ myThread=AfxBeginThread(myThreadProc,this);}
};
class parent_autoptr
{
public:
parent_autoptr()
{thisAutoMark=0;}
virtual ~parent_autoptr(){}
virtual void Release(){}
protected:
int thisAutoMark;
};
template<class T>
class auto_ptr :public parent_autoptr
{
public:
virtual void Release(){Remove();}
auto_ptr()
{mark=0;pointee=0;thisAutoMark=GetAutoMark();}
auto_ptr(auto_ptr<T>&rhs);
auto_ptr(T*ptr);
~auto_ptr(){Remove();}
T*operator->() const;
operator T*();
T&operator*()const;
auto_ptr<T>&operator=(auto_ptr<T>&rhs);
auto_ptr<T>&operator=(T*ptr);
private:
void Remove();
int GetAutoMark();
CMutex *GetCMutex();
void ReadyWrite();
T*pointee;
int mark;
};
template<class T> T* auto_ptr< T>::operator ->()const
{
return pointee;
}
template<class T> void auto_ptr< T>::ReadyWrite()
{
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
for(;;)
{
if(pMana->bCanWrite())
break;
}
}
}
template<class T> int auto_ptr< T>::GetAutoMark()
{
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
return pMana->GetAutoMark(this);
}
return 0;
}
template<class T> CMutex* auto_ptr< T>::GetCMutex()
{
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
CPtr * theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
return theCPtr->GetCMutex();
}
return NULL;
}
template<class T> void auto_ptr< T>::Remove()
{
CMutex * theMutex=GetCMutex();
if(theMutex)
{
CMySingleLock *pLock=new CMySingleLock(theMutex);
pLock->Lock();
BOOL bDeleteLock=FALSE;
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pointee&&pMana)
{
CPtr * theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
{
if(theCPtr->DeleteAutoPtr(this))
{
if(theCPtr->GetCount()==0)
{
pLock->Unlock();
delete pLock;
pMana->DeletePtr(mark,pointee);
bDeleteLock=TRUE;
delete pointee;
}
}
}
else
{
file://User decide to do
}
}
pointee=NULL;
mark=0;
if(!bDeleteLock)
delete pLock;
}
}
template<class T> auto_ptr< T>::operator T*()
{
return pointee;
}
template<class T> T& auto_ptr< T>::operator *()const
{
return *pointee;
}
template<class T> auto_ptr< T>::auto_ptr(auto_ptr<T>&rhs)
{
thisAutoMark=GetAutoMark();
ReadyWrite();
CMutex * theMutex=GetCMutex();
if(theMutex)
{
CSingleLock singleLock(theMutex);
singleLock.Lock();
pointee=rhs.pointee;
mark=rhs.mark;
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
CPtr* theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
{
theCPtr->AddAutoPtr(this,thisAutoMark);
}
}
}
}
template<class T> auto_ptr< T>::auto_ptr(T*ptr)
{
thisAutoMark=GetAutoMark();
ReadyWrite();
mark=0;
pointee=ptr;
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
mark=pMana->GetMarkFromPtr(ptr);
if(mark>0)
{
CPtr* theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
{
CMutex * theMutex=theCPtr->GetCMutex();
if(theMutex)
{
CSingleLock singleLock(theMutex);
singleLock.Lock();
theCPtr->AddAutoPtr(this,thisAutoMark);
}
}
}
}
}
template<class T>auto_ptr<T>& auto_ptr< T>::operator=(auto_ptr<T>&rhs)
{
if(pointee!=rhs.pointee)
{
ReadyWrite();
Remove();
pointee=rhs.pointee;
mark=rhs.mark;
CMutex * theMutex=GetCMutex();
if(theMutex)
{
CSingleLock singleLock(theMutex);
singleLock.Lock();
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
CPtr* theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
{
theCPtr->AddAutoPtr(this,thisAutoMark);
}
}
}
}
return *this;
}
template<class T> auto_ptr<T>&auto_ptr< T>::operator = (T* ptr)
{
if(pointee!=ptr)
{
ReadyWrite();
Remove();
pointee=ptr;
CPtrManager * pMana=CPtrManager::GetPtrManager();
if(pMana)
{
mark=pMana->GetMarkFromPtr(ptr);
if(mark>0)
{
CPtr* theCPtr=pMana->GetCPtr(pointee,mark);
if(theCPtr)
{
CMutex * theMutex=theCPtr->GetCMutex();
if(theMutex)
{
CSingleLock singleLock(theMutex);
singleLock.Lock();
theCPtr->AddAutoPtr(this,thisAutoMark);
}
}
}
}
}
return *this;
}
class test
{
public:
auto_ptr<test> p;
};
#endif // !defined(AFX_PTRMANAGER_H__BB4B38B5_DA34_11D3_9327_000629377185__INCLUDED_)
// PtrManager.cpp: implementation of the CPtrManager class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "PtrManager.h"
CPtrManager * CPtrManager::p_this=0;
void operator delete(void * p)
{
free(p);
}
void * operator new(size_t size)
{
CPtrManager * pMana=CPtrManager::GetPtrManager();
return pMana->MallocPtr(size);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CPtr::CPtr()
{
m_count=0;
m_mark=0;
m_ptr=0;
m_size=0;
AutoPtrArray.SetSize(0);
m_AutoMark.SetSize(0);
}
CPtr::~CPtr()
{
}
void * CPtr::GetPtr()
{
return m_ptr;
}
void CPtr::AddAutoPtr(void * autoPtr,int AutoMark)
{
int size=AutoPtrArray.GetSize();
AutoPtrArray.SetAtGrow(size,autoPtr);
m_AutoMark.SetAtGrow(size,AutoMark);
m_count++;
}
BOOL CPtr::DeleteAutoPtr(void * autoPtr)
{
int size=AutoPtrArray.GetSize();
for(int i=0;i<size;i++)
{
if(autoPtr==AutoPtrArray[i])
{
AutoPtrArray.RemoveAt(i);
m_AutoMark.RemoveAt(i);
m_count--;
return TRUE;
}
}
return FALSE;
}
int CPtr::GetCount()
{
return m_count;
}
void CPtr::SetPtr(void * thePtr,int Size,int mark,int count)
{
m_ptr=thePtr;
m_mark=mark;
m_size=Size;
m_count=count;
}
CMutex * CPtr::GetCMutex()
{
return &mutex;
}
int CPtr::GetPtrSize()
{
return m_size;
}
// class CPtrManager
CPtrManager::CPtrManager()
{
m_mark=0;
m_ptr.SetSize(1);
m_ptr[0]=0;
m_removed.SetSize(0);
p_this=this;
pCurrent=0;
bWrite=TRUE;
myThread=0;
BeginThread();
}
CPtrManager::~CPtrManager()
{
p_this=0;
if(myThread)
myThread->SuspendThread( );
int size=m_ptr.GetSize();
for(int i=1;i<size;i++)
{
if(m_ptr[i])
{
free(m_ptr[i]);
}
}
}
void CPtrManager::AddPtr(void *Ptr,int PtrSize)
{
CSingleLock singleLock(&mutex);
singleLock.Lock();
int size=0;
if(m_removed.GetSize()==0)
{
size =m_ptr.GetSize();
}
else
{
size=m_removed[0];
m_removed.RemoveAt(0);
}
if(size==0)
size=1;
CPtr * thePtr=new CPtr;
thePtr->SetPtr(Ptr,PtrSize,size);
m_ptr.SetAtGrow(size,thePtr);
pCurrent=Ptr;
m_mark=size;
}
void * CPtrManager::MallocPtr(size_t size)
{
CSingleLock singleLock(&mutex);
singleLock.Lock();
void * p=malloc(size);
if(p)
AddPtr(p,size);
return p;
}
void CPtrManager::DeletePtr(int mark,void*Ptr)
{
if(mark<=0||m_ptr.GetSize()<mark+1)
return ;
CSingleLock singleLock(&mutex);
singleLock.Lock();
if(m_ptr[mark])
{
CPtr * thePtr=(CPtr*)m_ptr[mark];
if(Ptr!=thePtr->GetPtr())
return ;
delete thePtr;
m_ptr[mark]=NULL;
m_removed.Add(mark);
}
}
int CPtrManager::GetMarkFromPtr(void * Ptr)
{
CSingleLock singleLock(&mutex);
singleLock.Lock();
if(pCurrent==Ptr)
return m_mark;
int size=m_ptr.GetSize();
for(int i=1;i<size;i++)
{
if(m_ptr[i]==Ptr)
return i;
}
return NULL;
}
CPtrManager * CPtrManager::GetPtrManager()
{
return p_this;
}
BOOL CPtrManager::bCanWrite()
{
return bWrite;
}
CPtr * CPtrManager::GetCPtr(void * Ptr,int mark)
{
if(!Ptr||mark<=0 || m_ptr.GetSize()<mark+1)
return NULL;
CSingleLock singleLock(&mutex);
singleLock.Lock();
if(m_ptr[mark])
{
CPtr * thePtr=(CPtr*)m_ptr[mark];
if(Ptr!=thePtr->GetPtr())
return NULL;
else
return thePtr;
}
return NULL;
}
int CPtrManager::GetAutoMark(void *ptr)
{
CSingleLock singleLock(&mutex);
singleLock.Lock();
int size =m_ptr.GetSize();
for(int i=1;i<size;i++)
{
CPtr* theCPtr=(CPtr*)m_ptr[i];
if(theCPtr)
{
int ptrFirst=(int)theCPtr->GetPtr();
int ptrEnd=ptrFirst+theCPtr->GetPtrSize();
int p=(int)ptr;
if(p>=ptrFirst&&p<=ptrEnd)
return i;
}
}
return 0;
}
void CPtrManager::RemoveLockRes()
{
CopyAllMark();
myMarkTable.DoLockMark();
}
void CPtrManager::CopyAllMark()
{
CSingleLock singleLock(&mutex);
singleLock.Lock();
CUIntArray theIntArray;
theIntArray.SetSize(0);
int size=m_ptr.GetSize();
for(int i=0;i<size-1;i++)
{
theIntArray.SetAtGrow(i,i+1);
}
bWrite=FALSE;
BOOL bALLCopyed=TRUE;
int TotalWhile=0;
do
{
TotalWhile++;
bALLCopyed=TRUE;
size=theIntArray.GetSize();
for(i=0;i<size;i++)
{
int m=theIntArray[i];
CPtr * theCPtr=(CPtr*)m_ptr[m];
if(theCPtr)
{
CMutex * theMutex;
theMutex=theCPtr->GetCMutex();
if(theMutex)
{
CMySingleLock * theLock;
theLock=new CMySingleLock(theMutex);
if(!theLock->IsLocked())
{
if(theLock->Lock(50))
{
CMark * theMark;
theMark=new CMark();
theMark->CopyFromCPtr(theCPtr);
delete theLock;
myMarkTable.AddCMark(theMark);
theIntArray.RemoveAt(i);
i--;
size--;
}
else
{
delete theLock;
bALLCopyed=FALSE;
}
}
else
{
delete theLock;
bALLCopyed=FALSE;
}
}
}
}
if(TotalWhile>=50)
break;
}while(!bALLCopyed);
bWrite=TRUE;
}
UINT CPtrManager::myThreadProc(LPVOID lparm)
{
CPtrManager* pana=(CPtrManager*)lparm;
if(!pana)
return 0;
Sleep(500);
for(;;)
pana->RemoveLockRes();
return 0;
}
file://begin class CMark
void CMark::CopyFromCPtr(CPtr *theCPtr)
{
if(!theCPtr)
return;
int size=(theCPtr->AutoPtrArray).GetSize();
automarkArray.SetSize(size);
autoptrArray.SetSize(size);
for(int i=0;i<size;i++)
{
automarkArray[i]=(theCPtr->m_AutoMark)[i];
autoptrArray[i]=(theCPtr->AutoPtrArray)[i];
}
m_mark=theCPtr->m_mark;
}
BOOL CMark::bIsNoneInStack()
{
int size=automarkArray.GetSize();
if(size==0)
return FALSE;
for(int i=0;i<size;i++)
{
if(automarkArray[i]<=0)
return FALSE;
}
return TRUE;
}
void CMark::Release()
{
int size=autoptrArray.GetSize();
for(int i=0;i<size;i++)
{
parent_autoptr * thePtr=
(parent_autoptr *)autoptrArray[i];
thePtr->Release();
}
}
file://end Calss CMark
file://begin class CMarkTable
void CMarkTable::AddCMark(CMark * theCMark)
{
if(theCMark)
CMarkArray.Add(theCMark);
}
BOOL CMarkTable::FindMark(int mark)
{
int size=CMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark * theMark=(CMark *)CMarkArray[i];
if(theMark)
{
if(mark==theMark->m_mark)
return TRUE;
}
}
return FALSE;
}
void CMarkTable::GetLockMark()
{
CLockMarkArray.SetSize(0);
int size=CMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark * theMark=(CMark*)CMarkArray[i];
if(theMark)
{
if(theMark->bIsNoneInStack())
CLockMarkArray.SetAtGrow(i,theMark);
}
}
}
void CMarkTable::RemoveUnlockMark()
{
CUIntArray UnlockMarkArray;
BOOL bNoneRemoveed;
do
{
bNoneRemoveed=TRUE;
UnlockMarkArray.SetSize(0);
int size=CLockMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark * theMark=(CMark*)CLockMarkArray[i];
if(theMark)
{
int size1=(theMark->automarkArray).GetSize();
for(int j=0;j<size1;j++)
{
int mark=(theMark->automarkArray)[j];
if(!FindLockMark(mark))
{
UnlockMarkArray.InsertAt(0,i); file://record to remove
bNoneRemoveed=FALSE;
break;
}
}
}
else
{
UnlockMarkArray.InsertAt(0,i);
bNoneRemoveed=FALSE;
}
}
int size2=UnlockMarkArray.GetSize();
for(int k=0;k<size2;k++)
{
int m=UnlockMarkArray[k];
CLockMarkArray.RemoveAt(m);
}
}while(!bNoneRemoveed);
}
BOOL CMarkTable::FindLockMark(int mark)
{
int size=CLockMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark * theMark=(CMark *)CLockMarkArray[i];
if(theMark)
{
if(mark==theMark->m_mark)
return TRUE;
}
}
return FALSE;
}
void CMarkTable::RemoveGroup(int automark)
{
int size=CLockMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark * theMark=(CMark *)CLockMarkArray[i];
if(theMark)
{
if(automark==theMark->m_mark)
{
CLockMarkArray.RemoveAt(i);
int size2=
(theMark->automarkArray).GetSize();
for(int j=0;j<size2;j++)
{
int auto_mark=
(theMark->automarkArray)[j];
RemoveGroup(auto_mark);
}
break;
}
}
}
}
void CMarkTable::DoLockMark()
{
GetLockMark();
RemoveUnlockMark();
int size=CLockMarkArray.GetSize();
while(size)
{
CMark* theMark=(CMark*)CLockMarkArray[0];
CLockMarkArray.RemoveAt(0);
if(theMark)
{
int size2=
(theMark->automarkArray).GetSize();
for(int i=0;i<size2;i++)
{
int automark=
(theMark->automarkArray)[i];
RemoveGroup(automark);
}
theMark->Release();
}
size=CLockMarkArray.GetSize();
}
Init();
}
void CMarkTable::Init()
{
int size=CMarkArray.GetSize();
for(int i=0;i<size;i++)
{
CMark* theMark=(CMark*)CMarkArray[i];
if(theMark)
delete theMark;
}
CMarkArray.SetSize(0);
CLockMarkArray.SetSize(0);
}
file://end class CMarkTable
