Forward declaration in C++ not working

[ducttape]

myProgram.cpp:

class childClass
{
          parentClass parent;  //reference to class that created this child
          childClass(parentClass p)
          {
                    parent = p;
          }
};
 
class parentClass
{
          childClass child(this);
};

This would work fine in Java, which I'm more accustomed to, but I need to do it in C++. The problem being that C++ compilers read classes sequentially and this code gives the error "error C2061: syntax error : identifier 'parentClass'" because it does not know what parentClass is yet. All the advice on the internet says to create a forward declaration for parentClass BEFORE the definition for childClass, and then keeping the definition for parentClass after childClass, such:

class parentClass;
 
class childClass
{
          parentClass parent;  //reference to class that created this child
          childClass(parentClass p)
          {
                    parent = p;
          }
};
 
class parentClass
{
          childClass child(this);
};

But this code then gives the error: "error C2079: 'myProgram::parent' uses undefined class 'parentClass'"

I've tried swapping around the classes, too, so that parentClass comes before childClass with a forward declaration for childClass. This gives the same error. I've also tried putting the classes in seperate *.cpp files. I must admit I don't really know how to do this, but the way I did it resulted in the same error (...uses undefined class...).

What do you think? I'm a decent Java and C# programmer but C++ is just taking the piss.

[Banfa]

When you forward declare a class you are just telling the compiler that a class with that name is going to exist. You can declare pointers and references from a forward declaration but you can not declare an instance of the class because the type is incomplete, the compiler only knows its name not its structure.

You can only declare an instance of the class once the class has been fully declared.

Where you declare this

          parentClass parent;  //reference to class that created this child
 

you are trying to declare a instance of the parentClass, the compiler can't do this because it does not know the structure of parentClass yet. Also this is not a reference. If you want a reference or a pointer you need to declare them like this

          parentClass &parent;  // reference to class that created this child
          parentClass *parent;  // pointer to class that created this child
 

My extremely limited and rusty Java is telling me that all objects are held as references in Java so you don't need to make this distinction between object, reference and pointer. Both of these declarations would work with a forward declaration.

Again the constructor you have defined for childClass takes a parentClass object as a parameter. Something that is not recomend in C++ (or C), passing whole objects of indeterminate size as parameters. Where you try to initialise it in parentClass you pass this, a pointer to the class.

I suggest you read up about C++ References and C pointers

I also note you appear to be trying to initialise child in your parentClass. The correct way to do this would be by attaching the initialisation to the definition of the constructor of the parentClass (the syntax you have used is being introduced in C++0x I believe)

parentClass::parentClass() :
          childClass child(this)
{
}
 

However you need to be careful when using the this pointer from the constructor as the class is not fully constructed yet so you can get odd side effects if you try to access members of the class.

Try reading Should you use the this pointer in the constructor?

[scruggsy]

         parentClass parent;  //reference to class that created this child

In Java I assume this would be a reference to some object. In C++ it is not. parent here is an object embedded into a child object. C++ needs to know the class layout of parent in order to determine the class layout of child.

Forward declarations simply tell the compiler a class exists:

class Mystery;
 
class Me {
  Mystery * mysteryPtr;   // this is fine
  void Do(Mystery& mystery);   // fine
  Mystery mystery;    // not fine
  Mystery::InnerClass inner;  // not fine
};
 
class Mystery {
  class InnerClass {
    //
  }
};

It seems to me if you just want ChildClass to remember its parent you would make parent a parentclass* or parentclass&.

[ducttape]

OK!! That's really helpful, I was assuming I was passing through a pointer just as in Java. As you may have guessed the code I posted was just a conceptual version, in the actual version the parent (a particle system) contains an array of children (particles) - I just want each child to have a pointer to its parent so it can ask it what it needs to look like when it respawns.

So, if I do something like this:

class childClass
{
          parentClass* parent;  //reference to class that created this child
          childClass(parentClass p)
          {
                    parent = p;
          }
};
 
class parentClass
{
          childClass child(this);
};
 

am I getting closer to the right idea? I will start reading those links you posted, thanks very much.

[Banfa]

Close but you need a * in

childClass(parentClass *p)

[ducttape]

Hi Banfa, I'm getting really close, I can feel it! I actually went and implemented that conceptual code in Visual Studio 2008 and I even got it to compile. So I added a variable to pass through to test it, and drew a blank. By the way, that article convinced me using "this" in the constructor was a bad idea. Here's the code, which results in the same error (..uses undefined class..)

#include "stdafx.h"
#include <iostream>
 
using namespace std;
 
class parentClass; //forward declaration of parentClass
 
class childClass
{
public:
    parentClass * parent;
    int someVar;
 
    childClass(){} //default constructor
 
    void setParent(parentClass *p)
    {
        parent = p;
    }
 
    void displayParentVar()
    {
        someVar = (*parent).parentVar;
        cout << someVar;
    }
 
};
 
class parentClass
{
public:
    childClass child;
    int parentVar;
 
    parentClass()
    {
        parentVar = 10;
        child = childClass();
        child.setParent(this);
    }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    parentClass myClass();
    return 0;
}
 

can you see what's wrong here?

[Banfa]

The problem is you are still trying to use parentClass before it has been defined in childClass::displayParentVar

class childClass
{
public:
//HERE 
    void displayParentVar()
    {
        someVar = (*parent).parentVar;
        cout << someVar;
    }
 
};
 

All other references to parentClass in childClass just use a pointer to it but here you are trying to access a member of parentClass which is not defined yet (only forward declared) so you get an error.

Your sequence has to be

1. Forward Declare parentClass
2. Declare childClass (only using pointers/references to parentClass)
3. Declare parentClass
4. Define childClass
5. Define parentClass

That is why we use separate headers(h) and code (cpp) files. We put the declaration of each class into 2 separate headers and the definition of each class into 2 separate code files. The 2 code files then both include both headers (in the same order normally) so that both classes are fully declared and then each file defines the member functions their own class in full view of those declarations.

Both headers are then included into the source file containing main so that you can create an instance of parentClass.

Your code needs this structure

// Forward declare parentClass
 
class childClass
{
// ... correct stuff snipped
public:
    void displayParentVar();
};
 
// Declare parentClass
 
// definition of child class member functions
void childClass::displayParentVar()
{
    someVar = (*parent).parentVar;
    cout << someVar;
}
 

You can define class functions within the class declaration but those functions are automatically inlined so you should only do this for functions with a few lines of code (and that don't use a forward declared type).

Also note that the shorthand for

someVar = (*parent).parentVar;

is

someVar = parent->parentVar;

Oh and that declaring someVar as a class variable is superfluous as it is only used locally to displayParentVar so could be declared locally to that function.

[ducttape]

I think I understand how headers work now. I can see the advantages and I'm going to split all my classes into seperate files from now on. So, I've split up the parent and the child class, made headers for them with their variables, and seperate .cpp files for their methods. The files all now #include each other.

The problem I'm getting now is error C1014: too many include files : depth = 1024. I figure its because class 1 includes class 2, which includes class 1, which includes class 2... I've tried the includes in many orders and left them out but because both classes need to know about each other I have a chicken and egg situation.

I can't see any way to resolve this because as soon as I make one class I need to have the other already made. I may have to go back to having it all in one file and use the order you suggested, but I'd really like to make it work with seperate files and headers.

[JosAH]

Use a guard that protects the preprocessor from going all the way down:

// parent.h:
#ifndef PARENT_H
#define PARENT_H
#include <child.h>
 
// your parent.h stuff here
 
#endif
 
// child.h:
#ifndef CHILD_H
#define CHILD_H
#include <parent.h>
 
// your child.h stuff here
 
#endif
 

kind regards,

Jos

[ducttape]

Thanks Jos, what do you mean, protect the preprocessor from going all the way down?

I added your code, it works if I leave out the #include in one of the classes, but if I put it in (which I obviously need to) it doesn't recognise it.

I include the code here in case I'm neglecting to tell you something.

//parentClass.h
#ifndef PARENTCLASS_H
#define PARENTCLASS_H
 
#include <string>
#include "childClass.h" //if I leave this out it works
 
using namespace std;
class parentClass
{      
  public:
      //constructor   s
      parentClass(string newName);
      //variables
      string name;
      //methods
      int someNumber();
      void setName(string newName);
};
 
#endif
 

//childClass.h
#ifndef CHILDCLASS_H
#define CHILDCLASS_H
 
#include "parentClass.h" 
 
#include <string>
using namespace std;
class childClass
{
  private:
      parentClass* parent;  //reference to class that created this child
  public:
      childClass(parentClass* p);
      string whoIsMyDaddy();
};
 
#endif
 

//childClass.cpp
#include "stdafx.h"
#include "childClass.h"
 
childClass::childClass(parentClass* p)
{
  parent = p;
}
 
string childClass::whoIsMyDaddy()
{
  return parent->name;
}
 

// parentClass.cpp
#include "stdafx.h"
#include "parentClass.h"
 
parentClass::parentClass(string newName)
{
  name = newName;
}
 
int parentClass::someNumber() 
{
  return 4;
}
 
void parentClass::setName(string newName)
{
  name = newName;
}
 

//main.cpp
#include "stdafx.h"
 
#include <iostream>
#include <string>
#include "childClass.h"
 
using namespace std;
 
int main(int argc, char *argv[])
{
    cout << "creating new parent class with name 'alex':\n";
    parentClass* p = new parentClass("alex");
    cout << "name from parent: " << p->name << "\n";
    cout << "creating new child class for parent:\n";
    childClass* c = new childClass(p);
    cout << "name from child:  " << c->whoIsMyDaddy()<< "\n\n";
 
    //change name and see what happens..
    cout << "changing parent name to 'Ivan':\n";
    p->setName("Ivan");
 
    cout << "name from parent: " << p->name << "\n";
    cout << "name from child:  " << c->whoIsMyDaddy()<< "\n";
 
    while(true);
 
    return 0;
}
 

[JosAH]

@ducttape
Something else is wrong then (incorrect file name?) because the guard mechanism is a well know idiom in C and C++ programming; you see it all over the world; it prevents the preprocessor from going down including A from B from A from B from A etc.

kind regards,

Jos

[ducttape]

Ok, that sounds like exactly what I need, I'll read up about the "guard mechanism" - is that what it's called? Perhaps you only need to put that guard around one of the classes to stop the preprocessor from going all the way down. I'll experiment and post my findings here. Thanks again

[ducttape]

I read up about include guards, I found this link helpful: http://www.efnetcpp.org/wiki/Include_guards

Unfortunately it seems like it's not what I need after all becuase it doesn't solve the original problem that A needs to have B defined and B needs to have A defined.

This is really messing with my head I feel like I'm going a bit crazy thinking about it. I'm kind of coming to the conclusion that you can't have two different classes with references to each other, ie. no instance of a class can know the instance that created it.

I'm going to try a different route to solve my problem. I need to pass information between the "parent" and the "child", specifically, once the parent has created an array of children, the children need to periodically as the parent what they need to look like. So if I create a third class which has variables to store all that information, thus:

informationClass
int someVar;

childClass(informationClass i) //constructor
informationClass * info = i;

parentClass
childClass children[1000]
informationClass info;

hopefully both child and parent will be able to access someVar.

I'll let you know how it goes.

[JosAH]

@ducttape
You may not realize it (yet) but those guards are exactly what you want; especially when those mutually dependant classes show up. It surprises me that you got an error when you included that file again. What exactly was the error that got reported by the compiler? It must've been something else ...

kind regards,

Jos

[Banfa]

It's not the files names. It's a basic problem with including headers mutually including other headers.

With your files as posted when the first file you include is parentClass.h it goes wrong. This is what happens.

1. Include parentClass.h set inclusion protection
2. parentClass.h: #include "childClass.h"
3. Include childClass.h set inclusion protection
4. childClass.h: #include "parentClass.h" (because childClass uses parentClass)
5. Include parentClass.h, protection inclusion is set so none of the code of the file is actually processed. Note at this point although we have include parentClass.h twice we have not yet processed class parentClass at all.
6. Back in childClass.h having finished processing parentClass.h from 5
7. Process class childClass. Oh dear child class uses parentClass and that is not yet declared.

This works OK when childClass.h is included first because parentClass does not use childClass in this example. If it did you would be in trouble.

It is almost always an error for A.H to include B.H and B.H to include A.H Avoid it if at all possible. In fact that is what a forward declaration is for. childClass.h should forward declare parentClass rather than including parentClass.h

You can still include childClass.h in parentClass.h if you wish (and if parentClass.h actually uses childClass but that depends on your projects header inclusion policy. The 4 common ones are
[list=1]Headers mustn't include other headers[*]Project headers can include system headers but not other project headers[*]Project headers should include all the headers so that if they are included no other include statements need to be added to the place that they are include into.[*]Do whatever the hell you like and leave the mess for someone else to tidy up.[list]

My personal preference is for 2. I have seen plenty of commercial attempt 3 and end up with 4.

[Banfa]

FYI Jos these are the errors

childClass.h:13: error: ISO C++ forbids declaration of ‘parentClass’ with no type
childClass.h:13: error: expected ‘;’ before ‘*’ token
childClass.h:15: error: expected `)' before ‘*’ token

when compiling parentClass.cpp

[JosAH]

@Banfa
Ah, I get it: in child.h the parentClass should be declared and in parent.h the childClass should be declared (that's what this entire discussion started).

The two next lines of error messages are just bogus given the first error.

kind regards,

Jos

edit: @OP: don't mix up 'definition' with 'declaration'; i.e. simply declare the existense of the other class in your .h files

[ducttape]

It's actually quite an interesting discussion, I always did wonder it was bad programming form on my part but I do it all the time in Java and C#: for the class that instantiates another class to pass itself through as a parameter so that the second class can refer to it as its parent. It's a really neat trick which saves bucketloads of code and I'd imagine saves bucketloads of memory. But if C++ doesn't allow it easily perhaps that's indicative of poor form.

I'm going to try my third inbetween class method and see how that works. I'll hopefully have it done by tomorrow and I'll report back. Till then, take care guys thanks for all your help.

[JosAH]

@ducttape
You don't need an inbetween class; define your classes in a .h file and only make the class refer to the other class as a reference or a pointer. Declare the existence of the other class before you define the class that belongs in your .h header file.

Also guard your two header files to prevent the preprocessor to dive in its recursion when two header files include eachother.

In your .cpp files you are free to do what you want after including the two header files. The classes are defined in the header files already.

Don't make a simple mistake of yours lead you to a complicated (artificial) solution. It's just the compiler that is too stupid to understand that an arbitrary word is supposed to be the name of a class. C++ is not Java.

kind regards,

Jos

ps. I cooked up a little skeleton:

#ifndef CHILD_H
#define CHILD_H
 
// tell the compiler this class exists:
class parentClass;
 
// define your class here:
class childClass {
   // only refer to the parent class as
   // parentClass* aPointerToParent; or
   // parentClass& aParentReference
}
 
#endif
 

Do the same for your parentClass (childClass <--> parentClass) and program away in your parent.cpp and child.cpp files where both classes are defined (because of the inclusion of the .h files).

[Banfa]

@JosAH
Are you saying that Java does treat any arbitrary keyword as a class (or class name)?

More seriously does Java void this problem because it does >1 pass compilation and therefore has visibility of all class names after the first pass?

[JosAH]

@Banfa
Nope, not saying that but the Java compiler is able to peek in compiled code; just enough to judge the code to be compiled for validity. That's where Java's 'classpath' comes in and that's why a lot of beginners are having trouble with it: they expect a certain level of psychic abilities from the compiler ;-)

kind regards,

Jos

[ducttape]

It's working with the forward declaration of childClass instead of the #include childClass. Thanks so much for your patience. In retrospect I'm embarassed that I too expected psychic abilities from the compiler. It just seemed so natural.

One of the starkest differences is that Java's variables are pointers by default. To create a new instance you actually have to use the "new" keyword. It seems to me to be a much more efficient way of doing things.

For anyone else reading this thread, if you change the code in the first block in post 10, line 6, from

#include "childClass.h"

to

class childClass;

it works. I still wonder about the quality of my code using a trick like that but it seems to work fine. Thanks again Banfa and JosAH you've been most kind.

[JosAH]

@ducttape
C++ can do that too but C++ carries a C heritage where objects can have value semantics, i.e. you don't just have a pointer (reference) to an object, as in Java, but you can plough your way through an object itself, anyway you want. That heritage is a mixed blessing.

kind regards,

Jos

ps. remember: everything needs to be declared before you can even mention it in other code. A definition counts as a declaration.

[ducttape]

I spoke too soon. I forgot my code example doesn't actually have a child belonging to the parent. If I try to add one, even if I forward declare childClass, I get error C2079: 'parentClass::c' uses undefined class 'childClass'. This is from simply adding a childClass variable to parentClass, not even from instantiating it.

[JosAH]

@ducttape
Here we go again: declare everything before you use it; if you just declare a class you can't use any of its members (because the compiler doesn't know about them), nor can you use the size of an object of the class. The guard mechanism as well as the forward declaration of the class(es) are enough to solve your problem.

kind regards,

Jos

[ducttape]

Thanks for your patience. Everything was declared and I was not using anything. I have guard mechanisms around all of my classes. I forward declared childClass and then added a childClass variable to parentClass. In childClass, I forward declared parentClass and added a parentClass variable to childClass. So far I have not defined anything or tried to use any of its members. If simply adding a variable requires you to define the class then logically the problem is unsolvable because declaring the variables is part of each classes definition.

I suspect you are right though, which means there must be some other error in my code that is causing the problem. I will try to figure it out when I have more time, unfortunately I need to get on with this project so I'm using my horrible artificial solution wth a third class. At least this way I never have to use "this" references or anything.

If I ever get it working I'll post my findings here. Till then, then.

[Banfa]

This is what we have been through in posts 1-6 of this thread.

The forward declaration does not allow you to declare a instance of the class but does allow you to declare a pointer to reference to the class.

You can then instantiate this pointer/reference using new in the class constructor.

You can do it where you define the constructor but not where you declare the class because the cpp file holding the member function definitions can have visibility of the declarations of both classes but the class declarations in the 2 headers can not have mutual visibility of each other.

That is if the childClass declaration is visible to the parentClass then the parentClass declaration can not be visible to the childClass. But the childClass can have visibility of a forward declaration of the parentClass name allowing it to declare pointers and references.