Serialize问题，请进！

[sinhua_ren]

CArray::Serialize(ar)函数，怎么不调用元素的Serialize(ar)？
帮忙看看哪出问题了

////////////////UserInfo.H
class CUserInfo : public CObject
{
DECLARE_SERIAL(CUserInfo);
public:
CUserInfo();
virtual ~CUserInfo();
public:
CString strName;
CString strAddress;
public:
CUserInfo& operator=(const CUserInfo& p); //重载=运算符
CUserInfo(const CUserInfo& p); //拷贝构造函数
virtual void Serialize(CArchive& ar); //重载Serialize

};
//////////////UserInfo.CPP
IMPLEMENT_SERIAL(CUserInfo,CObject,0)
CUserInfo::CUserInfo(){
}
CUserInfo::~CUserInfo(){
}
CUserInfo& CUserInfo::operator =(const CUserInfo& p)
{
strName=p.strName;
strAddress=p.strAddress;
return *this;
}
CUserInfo::CUserInfo(const CUserInfo& p)
{
*this=p;
}
void CUserInfo::Serialize(CArchive& ar)
{
if(ar.IsStoring())
{
ar<<strName<<strAddress;
}
else
{
ar>>strName>>strAddress;
}
}

////////////在文档类定义m_array
CArray<CUserInfo,CUserInfo&> m_array;

void CMyDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
}
else
{
}
m_array.Serialize(ar); ////元素CUserInfo::Serialize没有被调用
}

[lyg_zy]

因为虽然 m_array派生于CObject,但没有重载Serialize函数，正确的做法如下：
void CMyDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring() )
{
long n = myArray.GetCount();
ar << n;
for( i=0 ; i < n ;i++ )
{
CUserInfo& userInfo = m_array.ElementAt(i);
userInfo.Serialize(ar);
}
}
else
{
long n = 0 ;
ar >> n;
for( i=0;i < n;i++ )
{
CUserInfo userInfo ;
userInfo.Serialize( ar );
m_array.Add( userInfo );
}
}
}

[lyg_zy]

我说的"m_array派生于CObject,但没有重载Serialize函数"是错误的。
CArray派生于CObject类，重载Serialize函数，但它不会调用你的对象的Serialize函数，因为它是一个模板类，它不知道你给它的数据类型是什么，更不可能知道你的数据对象里有Serialize函数了。
看看CArray模板类的代码你就明白了：
template<class TYPE, class ARG_TYPE>
void CArray<TYPE, ARG_TYPE>::Serialize(CArchive& ar)
{
ASSERT_VALID(this);

CObject::Serialize(ar);
if (ar.IsStoring())
{
ar.WriteCount(m_nSize);
}
else
{
DWORD_PTR nOldSize = ar.ReadCount();
SetSize(nOldSize, -1);
}
SerializeElements<TYPE>(ar, m_pData, m_nSize);
}

template<class TYPE>
void AFXAPI SerializeElements(CArchive& ar, TYPE* pElements, INT_PTR nCount)
{
ASSERT(nCount == 0 ||
AfxIsValidAddress(pElements, (size_t)nCount * sizeof(TYPE)));

// default is bit-wise read/write
if (ar.IsStoring())
{
TYPE* pData;
UINT_PTR nElementsLeft;

nElementsLeft = nCount;
pData = pElements;
while( nElementsLeft > 0 )
{
UINT nElementsToWrite;

nElementsToWrite = UINT(min(nElementsLeft, INT_MAX/sizeof(TYPE)));
ar.Write(pData, nElementsToWrite*sizeof(TYPE));
nElementsLeft -= nElementsToWrite;
pData += nElementsToWrite;
}
}
else
{
TYPE* pData;
UINT_PTR nElementsLeft;

nElementsLeft = nCount;
pData = pElements;
while( nElementsLeft > 0 )
{
UINT nElementsToRead;

nElementsToRead = UINT(min(nElementsLeft, INT_MAX/sizeof(TYPE)));
ar.Read(pData, nElementsToRead*sizeof(TYPE));
nElementsLeft -= nElementsToRead;
pData += nElementsToRead;
}
}
}