I have a some arbitrary data class that is in charge of locking out concurrent access:
CMyData.h:
class CMyData
{
public:
CMyData(void);
virtual ~CMyData(void);
public:
void Get(CMyDataItem** ppMyData, int& nSize);
void Set(const CMyDataItem* pMyData, int nSize);
private:
CMyDataItem* m_pMyData; int m_nTableSize; CCriticalSection m_CriticalSection;
};
The implementations for Get and Set are:
void CMyData::Get(CMyDataItem** ppMyData, int& nSize)
{
CSingleLock lock(&m_CriticalSection, TRUE);
if(NULL != m_pMyData)
{
if(m_nTableSize != nSize || NULL == *ppMyData)
{
delete[] *ppMyData;
nSize = m_nTableSize;
*ppMyData = new CMyDataItem[m_nTableSize];
}
CopyMemory(*ppMyData, m_pMyData, sizeof(CMyDataItem)*m_nTableSize);
}
else
{
ASSERT(0); }
}
and
void CMyData::Set(const CMyDataItem* pMyData, int nSize)
{
CSingleLock lock(&m_CriticalSection, TRUE);
if(NULL != pMyData)
{
if(m_nTableSize != nSize)
{
m_nTableSize = nSize;
delete[] m_pMyData;
m_pMyData = new CMyDataItem[nSize];
}
CopyMemory(m_pMyData, pMyData, sizeof(CMyDataItem)*nSize);
}
else
{
ASSERT(0); }
}
If I repeat Get and Set a few times, at some point, the content of
m_pMyData
turns into gobbledygook, and I promise I haven't got any other way of changing the content of m_pMyData!
Calling example:
CMyDataItem* pMyData = NULL;
m_pMyData->Get(&pMyData);
pMyData->m_nID = 10;
m_pMyData->Set(pMyData);
delete[] pMyData;
pMyData = NULL;
Any ideas? Please help!
=============
PS:
Here is a bit more info.
class CMyDataItem
{
public:
CMyDataItem();
virtual ~CMyDataItem();
public:
int m_nSomeID;
int m_nAnotherID;
int m_nNumber;
double m_dValue1;
double m_dValue2;
double m_dValue3;
double m_dValue4;
double m_dValue5;
double m_dValue6;
double m_dValue7;
double m_dValue8;
double m_dValue9;
bool m_bBool1;
bool m_bBool2;
bool m_bBool3;
unsigned int m_uiMyID;
CString m_strString1;
CString m_strString2;
};