[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.c++

Why do I need to overload =

John Doe

10/7/2008 1:13:00 PM

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 ?
10 Answers

Victor Bazarov

10/7/2008 1:57:00 PM

0

John Doe wrote:
> 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 :
> [..]
> 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;
> };
> [...]
>
> 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 =

The compiler cannot generate one because you have reference members.
Once initialised (during construction), a reference cannot be reseated.

> 2) How can I fix it ?

You need to overload the assignment operator and decide what to do with
the 'strConfig' member (e.g. leave it alone) and the 'strOut' member.
*An example* of your operator= might look like this:

struct ThreadParam
{
...
ThreadParam& operator=(ThreadParam const& other)
{
pThis = other.pThis;
return *this;
}
};

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

John Doe

10/7/2008 2:22:00 PM

0

Victor Bazarov wrote:
> John Doe wrote:
>> 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 :
>> [..]
>> 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;
>> };
>> [...]
>>
>> 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 =
>
> The compiler cannot generate one because you have reference members.
> Once initialised (during construction), a reference cannot be reseated.
>
>> 2) How can I fix it ?
>
> You need to overload the assignment operator and decide what to do with
> the 'strConfig' member (e.g. leave it alone) and the 'strOut' member.
> *An example* of your operator= might look like this:
>
> struct ThreadParam
> {
> ...
> ThreadParam& operator=(ThreadParam const& other)
> {
> pThis = other.pThis;
> return *this;
> }
> };
>
> V
The problem is once I run :

m_thrParam = ThreadParam(this, strConfig, strXmlOut);
strConfig is a valid reference but strXmlOut is NULL ...

John Doe

10/7/2008 2:27:00 PM

0

John Doe wrote:
> Victor Bazarov wrote:
>> John Doe wrote:
>>> 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 :
>>> [..]
>>> 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;
>>> };
>>> [...]
>>>
>>> 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 =
>>
>> The compiler cannot generate one because you have reference members.
>> Once initialised (during construction), a reference cannot be reseated.
>>
>>> 2) How can I fix it ?
>>
>> You need to overload the assignment operator and decide what to do
>> with the 'strConfig' member (e.g. leave it alone) and the 'strOut'
>> member. *An example* of your operator= might look like this:
>>
>> struct ThreadParam
>> {
>> ...
>> ThreadParam& operator=(ThreadParam const& other)
>> {
>> pThis = other.pThis;
>> return *this;
>> }
>> };
>>
>> V
> The problem is once I run :
>
> m_thrParam = ThreadParam(this, strConfig, strXmlOut);
> strConfig is a valid reference but strXmlOut is NULL ...
>
>
>
I think I miss one important answer :
Once initialised (during construction), a reference cannot be reseated.

So what I want to do is not possible...

Barry

10/7/2008 2:38:00 PM

0

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

John Doe

10/7/2008 3:00:00 PM

0

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);
//m_thrParam.pStrConfig equals {0x001e5af0}
//m_thrParam.pStrOut equals {0x000ac248}

...
}



but in

/*static*/
DWORD CProvisioning::ProvisioningThr(LPVOID pvarg)
{
ThreadParam* pThrParam = static_cast<ThreadParam*>(pvarg);
if (pThrParam) {
COmaProvisioning* pThis = pThrParam->pThis;
if (pThis)
{
//pThrParam->pStrConfig is != 0x001e5af0 ????
//pThrParam->pStrOut is != 0x000ac248????
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 ?

John Doe

10/7/2008 3:16:00 PM

0

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.

John Doe

10/7/2008 3:32:00 PM

0

John Doe wrote:
> 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++

John Doe

10/7/2008 3:39:00 PM

0

> 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++
>
>

Hum I thinl I have understood why it couldn't work:


LPTSTR szXmlIn = NULL;
CString strXmlFmtOut;

m_OmaProv.ProcessConfigXML(szXmlIn, strXmlFmtOut);

When I call ProcessConfigXML , first argument is a C char array =>
CString objects are create temporarly then I save a pointer to ths
temporary object :

BOOL CProvisioning::ProcessConfigXML(const CString& strConfig, CString&
strXmlOut)
{
m_thrParam = ThreadParam(this, &strConfig, &strXmlOut);
....
}
So I suppose address of &strConfig is temporary ...

Am I wrong ?

Victor Bazarov

10/7/2008 7:52:00 PM

0

John Doe wrote:
> Victor Bazarov wrote:
>> John Doe wrote:
>>> 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 :
>>> [..]
>>> 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;
>>> };
>>> [...]
>>>
>>> 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 =
>>
>> The compiler cannot generate one because you have reference members.
>> Once initialised (during construction), a reference cannot be reseated.
>>
>>> 2) How can I fix it ?
>>
>> You need to overload the assignment operator and decide what to do
>> with the 'strConfig' member (e.g. leave it alone) and the 'strOut'
>> member. *An example* of your operator= might look like this:
>>
>> struct ThreadParam
>> {
>> ...
>> ThreadParam& operator=(ThreadParam const& other)
>> {
>> pThis = other.pThis;
>> return *this;
>> }
>> };
>>
>> V
> The problem is once I run :
>
> m_thrParam = ThreadParam(this, strConfig, strXmlOut);
> strConfig is a valid reference but strXmlOut is NULL ...

There is no such thing as a NULL reference. How do you get yours to be
"NULL"? Figure that, fix it, and then everything should be OK.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Victor Bazarov

10/7/2008 7:56:00 PM

0

John Doe wrote:
> [..]
> Hum I thinl I have understood why it couldn't work:
>
>
> LPTSTR szXmlIn = NULL;
> CString strXmlFmtOut;
>
> m_OmaProv.ProcessConfigXML(szXmlIn, strXmlFmtOut);
>
> When I call ProcessConfigXML , first argument is a C char array =>
> CString objects are create temporarly then I save a pointer to ths
> temporary object :
>
> BOOL CProvisioning::ProcessConfigXML(const CString& strConfig, CString&
> strXmlOut)
> {
> m_thrParam = ThreadParam(this, &strConfig, &strXmlOut);
> ...
> }
> So I suppose address of &strConfig is temporary ...
>
> Am I wrong ?

If you're receiving a reference to some temporary object and holding
onto it, that's your problem. Don't do that. When your class has
references as members, you basically go into the *contract* that the
objects to which those members refer live *longer* than the object that
contains those references. If the referred objects have a shorter
lifetime than the object that needs them, fix the lifetime or fix the
ownership.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask