"nested" classes

Hmm, I think I am out of luck here but still have to ask.

Class A includes a member instance of class B.
Class B includes a member instance of class A (actually just a pointer to the instance of A which owns it).

There is no way to declare this, is there? I was hoping I could go:

Code:

---

class A;
class B;

class A { complete declaration }
class B { complete declaration }

---

but B referred to in A produces "error: field B has incomplete type"

Maybe I can use a void pointer here for field B?

One of them needs to be a pointer.

You'll have to define B before A (since A has B as a member, but B doesn't have A as one).

Quote:

---

Originally Posted by anon

You'll have to define B before A (since A has B as a member, but B doesn't have A as one).

---

... with, of course, the forward declaration of class A (i.e., when defining class B, the compiler doesn't need to know the details of class A, just that the name exists).

The problem with using a pointer is that C++ seemingly doesn't allow me to use "void*" here, so the pointer must be of a type.

So class A must be defined before class B which must be defined before class A.

Quote:

---

Originally Posted by tabstop

... with, of course, the forward declaration of class A (i.e., when defining class B, the compiler doesn't need to know the details of class A, just that the name exists).

---

Sure, but the forward declaration of A includes a member of type B (or a pointer of same type, void* is no good). I was hoping just this would be okay:

Code:

---

class A;
class B:

---

But I now think that is actually meaningless in C++ (it does not count for anything).

You should know this from C: you cannot have A have a member of type B when B has a member of type A. You need to break this cyclic dependency with the use of a pointer or reference.

Quote:

---

Originally Posted by MK27

The problem with using a pointer is that C++ seemingly doesn't allow me to use "void*" here, so the pointer must be of a type.

So class A must be defined before class B which must be defined before class A.



Sure, but the forward declaration of A includes a member of type B (or a pointer of same type, void* is no good). I was hoping just this would be okay:

Code:

---

class A;
class B:

---

But I now think that is actually meaningless in C++ (it does not count for anything).

---

Again with the smoking things. You really should quit.

Code:

---

class A;
class B {
    private:
        A* parent;
        int data;
};

class A {
    private:
        B child;
};

int main() {
    return 0;
}

---

is a perfectly good program.

Quote:

---

Originally Posted by laserlight

You should know this from C: you cannot have A have a member of type B when B has a member of type A. You need to break this cyclic dependency with the use of a pointer or reference.

---

Yeah, but in C I would just use a void pointer. Is there no equivalent of that?

Related to this altho slightly theoretical right now, can I include a reference to self in an initializer list, eg:

Code:

---

A::A() : membB((void*)this) {

---

Here the membB is initialized with a pointer to the instance of A that owns it.

Quote:

---

Originally Posted by MK27

Yeah, but in C I would just use a void pointer. Is there no equivalent of that?

---

I would not use a void pointer in C for this case. See tabstop's post #7.

Quote:

---

Originally Posted by MK27

can I include a reference to self in an initializer list

---

I am not sure. It should be safe to access this in the constructor body though. (EDIT: ah, I read too deeply into the text of the Standard at one point; in another point, the use of the this pointer in a constructor initialisation list was demonstrated, with caveats, so it is not just something that just happens to work with current compilers, assuming that you do not trip over the caveats.)

There is no reason to use void*, because you can have a pointer / reference to incomplete, forward-declared type.

And yes, you can pass this, but the constructor of B needs to take into account that the A instance may not be fully constructed at that time. (You can store the pointer, but shouldn't do anything else with it.)

Quote:

---

Originally Posted by tabstop

is a perfectly good program.

---

Err, that is exactly what I tried to do the first time.

Quote:

---

Originally Posted by MK27

but B referred to in A produces "error: field B has incomplete type"

---

Altho at that time it was not a pointer; I've been presuming a pointer would be subject to the same restriction as it's type.

Quote:

---

Originally Posted by anon

There is no reason to use void*, because you can have a pointer / reference to incomplete, forward-declared type.

---

But maybe not. Will try.

Quote:

---

Originally Posted by MK27

Altho at that time it was not a pointer; I've been presuming a pointer would be subject to the same restriction as it's type.

---

It won't, since the compiler doesn't actually need to know how the class looks like if it's a pointer.
It needs the definition if it is a mere member, as it must parse for constructors and the like (hence needs to actually see the contents of the class).

So in the first, you can get away with a forward-declaration to merely tell the compiler the type exists. The definition only needs to be available when you implement the class.