Re: Why do I need to overload =

From:

John Doe <mosfet@anonymous.org>

Newsgroups:

comp.lang.c++

Date:

Tue, 07 Oct 2008 17:32:04 +0200

Message-ID:

<48eb80f5$0$16270$426a34cc@news.free.fr>

John Doe wrote:

Barry wrote:

On Oct 7, 9:13 pm, John Doe <mos...@anonymous.org> wrote:

Hi,

I am trying to transform a class with some time consuming operation by
adding a thread. To be able to pass data to thread I have declared a
class ThreadParam as shown below :

class CProvisioning
{
public:
        struct ThreadParam
        {
                ThreadParam(CProvisioning* a_pThis, const CString&
a_strConfig,
CString& a_strXmlOut):
                        pThis(a_pThis),
                        strConfig( a_strConfig ),
                        strOut( a_strXmlOut ) {}

                CProvisioning* pThis;
                const CString& strConfig;
                CString& strOut;
        };

        CProvisioning(void);
        ~CProvisioning(void);

        static DWORD ProvisioningThr(LPVOID pvarg);
        DWORD ProvisioningThr(const CString& strConfig, CString&
strXmlOut);

        BOOL ProcessConfigXML(const CString& strConfig, CString&
strOut);

protected:

        ThreadParam m_thrParam;
        HANDLE m_hProvThread;

};

CProvisioning::CProvisioning(void):
m_thrParam(this, CString(_T("")), CString(_T(""))),
m_hProvThread(NULL)
{

}

The ProcessConfig method receives two strings, one holding the config
file and the other to put the result:

BOOL CProvisioning::ProcessConfigXML(const CString& strConfig, CString&
strXmlOut)
{
        DWORD dwRet = 0;

         // Start a thread
        m_thrParam = ThreadParam(this, strConfig, strXmlOut);
        m_hProvThread = CreateThread(
                NULL,
                0,
                &CProvisioning::ProvisioningThr,
                &m_thrParam,
                0, NULL);
   ...

}

/*static*/
DWORD CProvisioning::ProvisioningThr(LPVOID pvarg)
{
        ThreadParam* pThrParam = static_cast<ThreadParam*>(pvarg);
        if (pThrParam) {
                CProvisioning* pThis = pThrParam->pThis;
                return
pThis->ProvisioningThr(pThis->m_thrParam.strConfig,
pThis->m_thrParam.strOut);
        }

        return -1;

}

DWORD CProvisioning::ProvisioningThr(const CString& strConfig, CString&
strXmlOut)
{
    // Some lengthy operations ...

    return 0;

}

The problem I get is with m_thrParam = ThreadParam(this, strConfig,
strXmlOut); because I get :

error C2582: 'operator =' function is unavailable in
'CProvisioning::ThreadParam'

1) First I don't understand why I need to overload =
2) How can I fix it ?

Beside reply by Victor else thread,
You can also have pointer as member instead of reference.

--
Best Regards
Barry

I have replaced reference by pointers but it still doesn 't work :
class CProvisioning
{
public:
struct ThreadParam
    {
        ThreadParam(CProvisioning* a_pThis, const CString*
a_strConfig, CString* a_strXmlOut):
            pThis(a_pThis),
            pStrConfig( a_strConfig ),
            pStrOut( a_strXmlOut ) {}

        CProvisioning* pThis;
        const CString* pStrConfig;
        CString* pStrOut;
    };
};

BOOL CProvisioning::ProcessConfigXML(const CString& strConfig,
CString& strXmlOut)
{
    DWORD dwRet = 0;

    m_thrParam = ThreadParam(this, &strConfig, &strXmlOut);

..
}

but in

/*static*/
DWORD CProvisioning::ProvisioningThr(LPVOID pvarg)
{
    ThreadParam* pThrParam = static_cast<ThreadParam*>(pvarg);
    if (pThrParam) {
        COmaProvisioning* pThis = pThrParam->pThis;
        if (pThis)
        {
            return pThis->ProvisioningThr(
                *pThis->m_thrParam.pStrConfig,
                *pThis->m_thrParam.pStrOut);
        }
           }

    return -1;
}

Address of pStrConfig and pStrOut are different from the one stored in
ProcessConfigXML.
Don't understand why ?

REALLY don't understand because m_thrParam address in ProcessConfigXML
and address received in DWORD CProvisioning::ProvisioningThr(LPVOID
pvarg) are the same but pointer contents are different

&m_thrParam 0x2e1dfc54 {pThis=0x2e1dfc54 pStrConfig=0x2e1d62c4
pStrOut=0x2e1d6290} CProvisioning::ThreadParam*

pThrParam 0x2e1dfc54 {pThis=0x2e1dfc54 pStrConfig=0x2e1d62c4
pStrOut=0x2e1d6290} CProvisioning::ThreadParam*

The problem is when debugging in ProcessConfigXML pStrConfig and
pStrOut holds valid data while in ProvisioningThr data is nonsense.

I have finally replaced CString* in ThreadParam with LPCTSTR
and LPTSTR:

struct ThreadParam
    {
        ThreadParam(CProvisioning* a_pThis, LPCTSTR a_strConfig, LPTSTR
a_strXmlOut):
            pThis(a_pThis),
            pStrConfig( a_strConfig ),
            pStrOut( a_strXmlOut ) {}

        CProvisioning* pThis;
        LPCTSTR pStrConfig;
        LPTSTR pStrOut;
    };

BOOL CProvisioning::ProcessConfigXML(const CString& strConfig, CString&
strXmlOut)
{
    DWORD dwRet = 0;

    m_thrParam = ThreadParam(this, (LPCTSTR)strConfig,
(LPTSTR)(LPCTSTR)strXmlOut);
    m_hProvThread = CreateThread(
        NULL,
        0,
        &COmaProvisioning::ProvisioningThr,
        &m_thrParam,
        0, NULL);
....
}
   /*static*/
DWORD CProvisioning::ProvisioningThr(LPVOID pvarg)
  {
      ThreadParam* pThrParam = static_cast<ThreadParam*>(pvarg);
      if (pThrParam) {
          COmaProvisioning* pThis = pThrParam->pThis;
          if (pThis)
          {
              return pThis->ProvisioningThr(
                  CString(pThis->m_thrParam.pStrConfig),
                  CString(pThis->m_thrParam.pStrOut);
          }
             }

      return -1;
  }

but obviously now my reference string passed in ProcessConfigXML is not
modified since I pass a temporary reference
CString(pThis->m_thrParam.pStrOut.

Finally I am going to use old plain C interface LPCTSTR and LPSTR
because like this it works ...
I don 't understand why I try complicated things in C++