class A uses class B, and B uses A

hi, im having some problem wih my classes,

class A has an pointer of type B.

and class B has a object of type A.

Code:

//FILE A.h
Class A{
	public:
		B* pb;
};

//FILE B.h
Class B{
	public:
		A objecta;
};

they are in different files, i've tried adding class B; before defining class A but i didnt work, i think because they are in separate files.

posted also in gamedev.

Well, A does not need B's definition. But it needs B's declaration, so you can use a forward declaration:

Code:

//FILE A.h

class B;

Class A{
	public:
		B* pb;
};

Then you include A's header in B:

Code:

//FILE B.h
#include "A.h"

Class B{
	public:
		A objecta;
};

Of course, the relevant header inclusion guards have been omitted as in your original example.

great!

that helped me understand more about forwarding class declarations, now is all working fine!.

thank you very much.

Note that this won't work if you create objects, and not pointers, because the constructor and destructor must be called, but since you only have a forward declaration, the compiler cannot see your full class definition and can't call the constructor.

Originally Posted by Elysia

Note that this won't work if you create objects, and not pointers, because the constructor and destructor must be called, but since you only have a forward declaration, the compiler cannot see your full class definition and can't call the constructor.

You can't even compile it if you aren't simply forward declaring a pointer (or reference?) to the class.

Huh?
You can declare pointers to a class to which you've added a forward declaration. Only, you must remember to include the real header in the source file which dereferences that pointer.

You guys/gals are saying the same thing . . . .

I didn't think you could declare references based on forward declarations -- until I tried it. (Deja vu . . . .)

Code:

#include <iostream>

class b;
class a { class b &bb; };
class b { class a &aa; };

int main() { return 0; }

On the other hand, this does not work:

Code:

#include <iostream>

class b;

class a {
public:
    class b &bb;
    void set() { std::cout << "a::set()\n"; }
    void setother() { bb.set(); }
};

class b {
public:
    class a &aa;
    void set() { std::cout << "b::set()\n"; }
    void setother() { aa.set(); }
};

int main() {
    a aa;
    b bb;
    aa.set();
    aa.setother();
    bb.set();
    bb.setother();
    return 0;
}

(Sorry, Elysia.)

I guess it follows the same principles as declaring pointers to forward-declared objects: you can do it, but you can't access anything inside the object without having a full declaration.

Yes, don't inline functions in the header. It's... error prone.

I just did it because it's much more convenient to type into cat.

Besides, that's not a header -- it's a declaration of a class (or two classes, I suppose); but it's not in a header file, it's in a source file.

So then you should actually include the headers with the class definitions instead of forward declaring the classes!
Your inlining is why the second sample won't work, as you are aware...