Why do I need to overload =

Discussion in 'C++' started by John Doe, Oct 7, 2008.

  1. John Doe

    John Doe Guest

    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 ?
     
    John Doe, Oct 7, 2008
    #1
    1. Advertising

  2. John Doe

    John Doe Guest

    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, Oct 7, 2008
    #2
    1. Advertising

  3. John Doe

    John Doe Guest

    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...
     
    John Doe, Oct 7, 2008
    #3
  4. John Doe

    Barry Guest

    On Oct 7, 9:13 pm, John Doe <> 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
     
    Barry, Oct 7, 2008
    #4
  5. John Doe

    John Doe Guest

    Barry wrote:
    > On Oct 7, 9:13 pm, John Doe <> 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, Oct 7, 2008
    #5
  6. John Doe

    John Doe Guest

    John Doe wrote:
    > Barry wrote:
    >> On Oct 7, 9:13 pm, John Doe <> 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, Oct 7, 2008
    #6
  7. John Doe

    John Doe Guest

    John Doe wrote:
    > John Doe wrote:
    >> Barry wrote:
    >>> On Oct 7, 9:13 pm, John Doe <> 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, Oct 7, 2008
    #7
  8. John Doe

    John Doe Guest

    > 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 ?
     
    John Doe, Oct 7, 2008
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Piotre Ugrumov
    Replies:
    3
    Views:
    377
    Nick Hounsome
    Jan 25, 2004
  2. Teddy
    Replies:
    5
    Views:
    9,625
    Swampmonster
    Jun 10, 2005
  3. Mr. SweatyFinger

    why why why why why

    Mr. SweatyFinger, Nov 28, 2006, in forum: ASP .Net
    Replies:
    4
    Views:
    922
    Mark Rae
    Dec 21, 2006
  4. Mr. SweatyFinger
    Replies:
    2
    Views:
    2,076
    Smokey Grindel
    Dec 2, 2006
  5. Ying-Chieh Liao

    function overload (not operator overload)

    Ying-Chieh Liao, Oct 11, 2004, in forum: Perl Misc
    Replies:
    3
    Views:
    260
    Sherm Pendley
    Oct 11, 2004
Loading...

Share This Page