How to create an initialised object declared as a class member variable?

I am working on a VC6++ project that involve an object to be initialised
by a 'this' pointer pointing to another object. I encountered, however,
a syntax error. I wonder if someone can help. See the code below. What I
couldn't figure out is it is OK with

CMyClassA B2(this);

in fileB.cpp but a SYNTAX ERROR with

CMyClassA m_B2(this);

in fileB.h. What should I do in order to create a initialised object of
CMyClassA if I really need a class member variable (m_B2) rather than a local (B2)?

Thanks for any help.


/////////////////////////// fileA.h ///////////////////////////
//
// forward declaration
class CMyClassB;

// CMyClassA declaration
class CMyClassA{
public:
CMyClassB* m_ptA;

public:
CMyClassA();
CMyClassA(CMyClassB* ptB);
};


/////////////////////////// fileA.cpp /////////////////////////
//
#include "fileA.h"

// constructor 1
CMyClassA::CMyClassA(void){
// ... whatever ...
}

// constructor 2
CMyClassA::CMyClassA(CMyClassB* ptB){
m_ptA = ptB;
}


/////////////////////////// fileB.h ///////////////////////////
//
#include "fileA.h"

class CMyClassB{
public:
CMyClassA m_B1; // no problem
CMyClassA m_B2(this); // syntax error : 'this', WHY???

public:
CMyClassB(void);
};


/////////////////////////// fileB.cpp //////////////////////////

#include "fileB.h"

CMyClassB::CMyClassB(void){
CMyClassA B1; // no problem
CMyClassA B2(this); // no problem
}


int main(void){
// ... whatever ...
return 1;
}

Try this

[color=blue]
>
> /////////////////////////// fileB.h ///////////////////////////
> //
> #include "fileA.h"
>
> class CMyClassB{
> public:
> CMyClassA m_B1; // no problem
> CMyClassA m_B2; // we won't call constructor here
>
> public:
> CMyClassB(void);
> };
>
>
> /////////////////////////// fileB.cpp //////////////////////////
>
> #include "fileB.h"
>
> CMyClassB::CMyClassB(void)
> : m_B2(this) // we will call it here instead ( hope there is no problem[/color]
with passing 'this' pointing to not fully constructed object )[color=blue]
>{
> CMyClassA B1; // no problem
> CMyClassA B2(this); // no problem
> }
>
>
> int main(void){
> // ... whatever ...
> return 1;
> }[/color]

CFF wrote:[color=blue]
>
> /////////////////////////// fileB.h ///////////////////////////
> //
> #include "fileA.h"
>
> class CMyClassB{
> public:
> CMyClassA m_B1; // no problem
> CMyClassA m_B2(this); // syntax error : 'this', WHY???[/color]

Because this is not the way initializations are specified in C++
What you need is a constructor for CMyClassB, which does the initialization


CMyClassB() : m_B2( this ) {}


--
Karl Heinz Buchegger
kbuchegg@gascad.at

Karl Heinz Buchegger wrote:[color=blue]
>
> CFF wrote:[color=green]
> >
> > /////////////////////////// fileB.h ///////////////////////////
> > //
> > #include "fileA.h"
> >
> > class CMyClassB{
> > public:
> > CMyClassA m_B1; // no problem
> > CMyClassA m_B2(this); // syntax error : 'this', WHY???[/color]
>
> Because this is not the way initializations are specified in C++
> What you need is a constructor for CMyClassB, which does the initialization
>
> CMyClassB() : m_B2( this ) {}[/color]

Oh. I see you already have a constructor. So add the initialization
to that constructor


--
Karl Heinz Buchegger
kbuchegg@gascad.at

"kamil" <kamildobk@xxxpoczta.onet.pl> wrote in message news:<#5#djPRhEHA.704@TK2MSFTNGP12.phx.gbl>...[color=blue]
> Try this
>
>[color=green]
> >
> > /////////////////////////// fileB.h ///////////////////////////
> > //
> > #include "fileA.h"
> >
> > class CMyClassB{
> > public:
> > CMyClassA m_B1; // no problem
> > CMyClassA m_B2; // we won't call constructor here
> >
> > public:
> > CMyClassB(void);
> > };
> >
> >
> > /////////////////////////// fileB.cpp //////////////////////////
> >
> > #include "fileB.h"
> >
> > CMyClassB::CMyClassB(void)
> > : m_B2(this) // we will call it here instead ( hope there is no problem[/color]
> with passing 'this' pointing to not fully constructed object )[color=green]
> >{
> > CMyClassA B1; // no problem
> > CMyClassA B2(this); // no problem
> > }
> >
> >
> > int main(void){
> > // ... whatever ...
> > return 1;
> > }[/color][/color]

Thank you for your help. I've tried it out and it works. But ... I am
getting a warning message saying

"warning C4355: 'this' : used in base member initializer list"

when complied. I am a bit worry about this. Any idea about what's the
problem with it? Does it cause any undersirable effect? Thanks again.

I think as long as you don't try to manipulate the half-constructed
object, you're fine. I believe I do this very thing in some piece of
software I wrote, and I have seen no ill effects. The compiler is just
reminding you... you can always disable the warning with a #pragma.

CFF wrote:[color=blue]
> "kamil" <kamildobk@xxxpoczta.onet.pl> wrote in message news:<#5#djPRhEHA.704@TK2MSFTNGP12.phx.gbl>...
>[color=green]
>>Try this
>>
>>
>>[color=darkred]
>>>/////////////////////////// fileB.h ///////////////////////////
>>>//
>>>#include "fileA.h"
>>>
>>>class CMyClassB{
>>>public:
>>>CMyClassA m_B1; // no problem
>>>CMyClassA m_B2; // we won't call constructor here
>>>
>>>public:
>>>CMyClassB(void);
>>>};
>>>
>>>
>>>/////////////////////////// fileB.cpp //////////////////////////
>>>
>>>#include "fileB.h"
>>>
>>>CMyClassB::CMyClassB(void)
>>>: m_B2(this) // we will call it here instead ( hope there is no problem[/color]
>>
>> with passing 'this' pointing to not fully constructed object )
>>[color=darkred]
>>>{
>>>CMyClassA B1; // no problem
>>>CMyClassA B2(this); // no problem
>>>}
>>>
>>>
>>>int main(void){
>>>// ... whatever ...
>>>return 1;
>>>}[/color][/color]
>
>
> Thank you for your help. I've tried it out and it works. But ... I am
> getting a warning message saying
>
> "warning C4355: 'this' : used in base member initializer list"
>
> when complied. I am a bit worry about this. Any idea about what's the
> problem with it? Does it cause any undersirable effect? Thanks again.[/color]