如何在结构链表中生成动态数组？

[OnDraw]

////////my.h
struct chararray
{
char *name;
char *path;
chararray *charpoint;
};


程序中用以下方法生成后竟然链表中的每一项name和path的值都一样，调试时发现
链表的地址虽然变了但是每个动态字符数组的地址居然都是一样的。
/////////my.cpp
chararray myuse;
myuse->name=new char[10];
myuse->name=......;
myuse=myuse->charpoint;

[OnDraw]

同志，帮帮忙吧

[csdnflysnow]

程序都是错误。
yuse->name=new char[10];
myuse->name=......; //内存泄漏

myuse=myuse->charpoint; //?? 首先myuse->charpoint没赋值，一个指针，一个对象怎么能赋值

[OnDraw]

To:DoItFreely(Freely)　同志，感谢贴出这么多的代码，程序复杂我需要慢慢研究，

另To:csdnflysnow() 同志，源程序错的不在那几个地方，以上疏忽，并且简化了一部分造成了上述的结果，我把完整一点的程序贴上来，请看看为什么有问题，谢了！

///////////////////.h/////////////////////
struct chararray
{
char *name;
char *path;
chararray *charpoint;
};
chararray* arraystart;

///////////////////.cpp//////////////////////
arraystart=NULL;
chararray* typeuse=NULL,*typeold;
FILE *fr;
int local;
char myinfo[100];
CString mystr;
fr=fopen("lotter.ini","rb");//打开文件
while((fgets(myinfo,100,fr))!=NULL)//我读
{
mystr=myinfo;
local=mystr.Find("NAME=",0);//我查
if(local==0)
{
typeuse=new chararray;
if(arraystart==NULL)
arraystart=typeuse;//头指针
else
typeold->charpoint=typeuse;
typeuse->name=new char[mystr.GetLength()];//动态分配
typeuse->name=mystr.GetBuffer(mystr.GetLength());//赋值
typeold=typeuse;
}
}

[OnDraw]

急啊

[OnDraw]

同志们，帮一帮忙吧

[DoItFreely]

我有一个链表的模板：(关于CMutexObj类是用来实现单独存取的，你可以不管)
#if !defined(COLLECTIONLIST_H)
#define COLLECTIONLIST_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "MutexObj.h"

struct ColList
{
struct ColList *pPrior;
struct ColList *pNext;
LPVOID pData;
};

typedef struct ColList COLLIST;
typedef COLLIST *PCOLLIST;

template<class ARG_TYPE>
class CCollectionList
{
public:
CCollectionList();
~CCollectionList();
ARG_TYPE* Find(int nIndex=-1);
ARG_TYPE* Find(ARG_TYPE *pObj);
int GetIndex(ARG_TYPE *pObj);
BOOL InsertItem(ARG_TYPE *pObj,int nBefore=-1);
BOOL RemoveItem(int nIndex=-1,BOOL bDelete=TRUE);
ARG_TYPE* operator[](int nIndex);
void Empty();
int GetCount();
protected:
PCOLLIST m_pList;
int m_nCount;
CMutexObj m_Lock;
};

template <class ARG_TYPE>
inline CCollectionList<ARG_TYPE>::CCollectionList()
{
m_nCount = 0;
m_pList = NULL;
}

template <class ARG_TYPE>
inline CCollectionList<ARG_TYPE>::~CCollectionList()
{
Empty();
}

template <class ARG_TYPE>
inline ARG_TYPE* CCollectionList<ARG_TYPE>::Find(int nIndex)
{
if(nIndex>=m_nCount) return NULL;
ARG_TYPE* p = NULL;
m_Lock.Lock();
nIndex = nIndex>=0 ? nIndex : m_nCount - 1;
PCOLLIST pItem = m_pList;
for(;nIndex>0;nIndex--)
{
pItem = pItem->pNext;
}
ASSERT(pItem);
p = (ARG_TYPE*)pItem->pData;
m_Lock.Unlock();
return p;
}

template <class ARG_TYPE>
inline ARG_TYPE* CCollectionList<ARG_TYPE>::Find(ARG_TYPE *pObj)
{
ARG_TYPE* p = NULL;
int nIndex = GetIndex(pObj);
if(nIndex>=0) p = Find(nIndex);
return p;
}

template <class ARG_TYPE>
inline int CCollectionList<ARG_TYPE>::GetIndex(ARG_TYPE *pObj)
{
BOOL bFound = FALSE;
int i;
m_Lock.Lock();
PCOLLIST p = m_pList;
if(p)
{
for(i=0;;i++)
{
if(!p->pData) break;
if(p->pData==pObj)
{
bFound = TRUE;
break;
}
if(!p->pNext) break;
p = p->pNext;
}
}
m_Lock.Unlock();
return bFound ? i : -1;
}

template <class ARG_TYPE>
inline BOOL CCollectionList<ARG_TYPE>::InsertItem(ARG_TYPE *pObj,int nBefore)
{
int i;
PCOLLIST pItem = new COLLIST;
pItem->pData = pObj;
m_Lock.Lock();
PCOLLIST p = m_pList;
if(!m_nCount)
{
pItem->pPrior = NULL;
pItem->pNext = NULL;
m_pList = pItem;
m_nCount++;
}
else
{
nBefore = m_nCount>=nBefore ? nBefore : m_nCount;
nBefore = nBefore>=0 ? nBefore : m_nCount;//last one or insert into middle
for(i=nBefore;i>1;i--) p = p->pNext;
pItem->pNext = p->pNext;
if(p->pNext) p->pNext->pPrior = pItem;
p->pNext = pItem;
pItem->pPrior = p;
m_nCount++;
}
m_Lock.Unlock();
return TRUE;
}

template <class ARG_TYPE>
inline BOOL CCollectionList<ARG_TYPE>::RemoveItem(int nIndex,BOOL bDelete)
{
if(nIndex>=m_nCount) return FALSE;
BOOL bRemoved = FALSE;
m_Lock.Lock();
nIndex = nIndex>=0 ? nIndex : m_nCount;
PCOLLIST p = m_pList;
for(int i=nIndex;i>0;i--) p = p->pNext;
ASSERT(p);
if(bDelete)
{
ARG_TYPE *pObj = (ARG_TYPE *)p->pData;
delete [] pObj;
}
if(p->pPrior) p->pPrior->pNext = p->pNext;
if(p->pNext) p->pNext->pPrior = p->pPrior;
delete p;
bRemoved = TRUE;
m_nCount--;
if(!m_nCount) m_pList = NULL;
m_Lock.Unlock();
return bRemoved;
}

template <class ARG_TYPE>
inline void CCollectionList<ARG_TYPE>::Empty()
{
m_Lock.Lock();
PCOLLIST p = m_pList;
PCOLLIST pTemp;
ARG_TYPE *pObj;
for(;p;)
{
pObj = (ARG_TYPE *)p->pData;
delete [] pObj;
pTemp = p->pNext;
delete p;
p = pTemp;
}
m_pList = NULL;
m_nCount = 0;
m_Lock.Unlock();
}

template <class ARG_TYPE>
inline int CCollectionList<ARG_TYPE>::GetCount()
{
return m_nCount;
}

template <class ARG_TYPE>
inline ARG_TYPE* CCollectionList<ARG_TYPE>::operator[](int nIndex)
{
ASSERT(nIndex>=0 && nIndex<m_nCount);
ARG_TYPE *pObj = Find(nIndex);
ASSERT(pObj);
return pObj;
}

#endif // !defined(COLLECTIONLIST_H)






///////////////////
使用：
CCollectionList<char>CharList;
char *p = new char[30];
strcpy(p,something_need_save_but_cannot_change);
CharList.InsertItem(p);//Insert as last one
//you can reference p, but don't change its size or delete it after insertitem()