How to access public members of the class containing the object

Hi experts,

Is it possible in C++ to access public members of the class containing the object?

For example, in this way it is impossible:

class AClass
{
public:
      BClass m_BClass; // impossible!
      m_BClass->m_AClass = this;
      
      int test;
}

class BClass
{
public:
      AClass* m_ AClass;
      void Test();
}

void BClass::Test()
{
      int test = m_ AClass->test;
}

I am asking that because in Java it is possible, since there classes are grouped in packages...
pamirAsked:
Who is Participating?
 
evilrixConnect With a Mentor Senior Software Engineer (Avast)Commented:
You need to (a) reorder a little and (b) forward declare.
http://www.devx.com/tips/Tip/12583
class AClass;
 
class BClass
{
public:
	AClass* m_AClass;
	void Test();
};
 
class AClass
{
public:
	BClass m_BClass; // impossible!
 
	AClass()
	{
		m_BClass.m_AClass = this;
	}
 
	int test;
};
 
void BClass::Test()
{
	int test = m_AClass->test;
}

Open in new window

0
 
evilrixSenior Software Engineer (Avast)Commented:
^^^Oops, I forgot to remove the "// impossible!" from the code I reordered -- ignore it, it is possible :)
0
 
Deepu AbrahamR & D Engineering ManagerCommented:
Class is blue print of an object,You need to write this in a public fuction
<return type> <some function name>()
{
m_BClass.m_AClass = this;
}

or in a constuctor.
0
Get your problem seen by more experts

Be seen. Boost your question’s priority for more expert views and faster solutions

 
pamirAuthor Commented:
Thanks evilrix,
I see that line 1 in your code is doing the trick.

Howerver, in my real situation, I am using header files and I am receiving an error:
BClass.cpp(14) : error C2027: use of undefined type 'AClass'

So I am wondering what is wrong here?

The code is:

AClass.h:
=======================================================================
#pragma once
#include ".\bclass.h"

class AClass
{
public:
      AClass(void);
      ~AClass(void);

      BClass m_BClass;
      int test;
};


AClass.cpp:
=======================================================================
#include "StdAfx.h"
#include ".\aclass.h"

AClass::AClass(void)
{
      m_BClass.m_AClass = this;
}

AClass::~AClass(void)
{
}


BClass.h:
=======================================================================
#pragma once

class AClass;

class BClass
{
public:
      BClass(void);
      ~BClass(void);

      AClass* m_AClass;
      int test;

      void Test();
};


BClass.cpp:
=======================================================================
#include "StdAfx.h"
#include ".\bclass.h"

BClass::BClass(void)
{
}

BClass::~BClass(void)
{
}

void BClass::Test()
{
      test = m_AClass->test;
}
0
 
evilrixSenior Software Engineer (Avast)Commented:
You need to include aclass.h in bclass.cpp

The forward declaration only allows you to define a pointer or reference, to use it the compiler must see the full class definition.

BTW (off topic): Don't prefix  .\ to file names when including headers, it's not portable. Since the headers are in the same folder as the .cpp files just use "aclass.h". If you do need to use a path you should use / and not \ as the / char is portable on both Windows and Linux where as \ is a Windows only seperator.
0
 
pamirAuthor Commented:
P.S. the error is in the line
 test = m_AClass->test;
0
 
evilrixSenior Software Engineer (Avast)Commented:
^^^ oh, and "#pragma once" isn't portable either, prefer to use include guards.
http://en.wikipedia.org/wiki/Include_guard
0
 
evilrixSenior Software Engineer (Avast)Commented:
>> You need to include aclass.h in bclass.cpp
See below.

AClass.h:
=======================================================================
#pragma once
#include ".\bclass.h"
 
class AClass
{
public:
      AClass(void);
      ~AClass(void);
 
      BClass m_BClass;
      int test;
};
 
 
AClass.cpp:
=======================================================================
#include "StdAfx.h"
#include ".\aclass.h"
 
AClass::AClass(void)
{
      m_BClass.m_AClass = this;
}
 
AClass::~AClass(void)
{
}
 
 
BClass.h:
=======================================================================
#pragma once
 
class AClass;
 
class BClass
{
public:
      BClass(void);
      ~BClass(void);
 
      AClass* m_AClass;
      int test;
 
      void Test();
};
 
 
BClass.cpp:
=======================================================================
#include "StdAfx.h"
#include ".\bclass.h"
#include "abclass.h" // <--- LOOK !!!
 
BClass::BClass(void)
{
}
 
BClass::~BClass(void)
{
}
 
void BClass::Test()
{
      test = m_AClass->test;
}

Open in new window

0
 
pamirAuthor Commented:
Yes, it works, the forward declarations are very useful, thanks a lot!

OK, I have read the include guards article, and also the article for #pragma once http://en.wikipedia.org/wiki/Pragma_once - but it seems that #pragma once does the work with less code?...
0
 
evilrixSenior Software Engineer (Avast)Commented:
>> #pragma once does the work with less code?...
It does but it is NOT part of the C/C++ standard, it is a Microsoft only extension. As long as you know this and are happy to accept your code will not be portable then use it as your wish but if you need to write code to compile on other platforms then you cannot use it.

It was just an advisory :)
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.