C / C++ / MFC

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

for (int x = 0; x < 117; x++)
{
    int &r = x;
    int *p = &x;
 
    // both of these indirectly change the value of x
    r  = 116547629;
    *p = 116547629;
}

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

int i = 0;
while (i < 10000)
   ...

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

class1.h
#pragma once
#include "class2.h"
 
class class2; // <-- forward declaration. do the same thing in class2.h

class class1 {
  private:
  class2 *child1;
  class2 *child2;
public:
  class1() 
  {
    child1 = new class2();
    child1->Init();
    child2 = new class2();
    child2->Init();
  }
};

<br />
// class1.h<br />
#pragma once<br />
<br />
class class2;<br />
<br />
class class1<br />
{<br />
private:<br />
   class2* child1;<br />
   class2* child2;<br />
<br />
public:<br />
   class1()<br />
   {<br />
     child1 = new class2(this);<br />
     child2 = new class2(this);<br />
   }<br />
};<br />
<br />
// class2.h<br />
#pragma once<br />
<br />
class class1;<br />
<br />
class class2<br />
{<br />
private:<br />
   class1* parent;<br />
<br />
public:<br />
   class2(class1* the_parent) : parent(the_parent)<br />
   {<br />
   }<br />
};<br />

• finds an include for "class2.h", so it goes for it.
• finds an include for "class1.h", so it goes for it.
• compiles the declaration for class1. Nothing else in this file, so it returns to class2.h
• finds an include for "struct1.h", so it goes for it.
• finds an include for "class2.h", but it's already started processing that file, and noted a "pragma once" directive, so it ignores this include.
• finds a forward declaration for class2, so it says to itself "I now know class2 is a class, even if I still don't know all the details"
• starts compiling the declaration for struct1. Finds the declaration of "item" as a pointer to a "class2". At this point, the compiler only needs to know wether the type of "item" is valid, and how much space it takes to store it. It does know the type is valid because of the forward declaration. And it does know how much space is needed for "item", because all pointers are the same size. Compilation goes on.
• It now reaches the line with "new class2()" in it, so it needs to create a call to some constructor of class2 with no parameters. The problem is it hasn't actually seen the complete declaration of class2 yet, so it doesn't know if such constructor exists

////////////////////////////////////////////////////////
// class1.h - Put class declaration here

#pragma once

class class1
{
public:
   class1();

// Other members' declarations
};


////////////////////////////////////////////////////////
// class1.cpp - Put class implementation here

#include "class1.h"

class1::class1()
{
}

// Other members' implementations


////////////////////////////////////////////////////////
// class2.h - Put class declaration here

#pragma once

#include "class1.h"

struct struct1;

class class2 : public class1
{
private:
   struct1* cfg;

public:
   class2();

   void Init(struct1* data);
};


////////////////////////////////////////////////////////
// class2.cpp - Put class implementation here

#include "class2.h"

class2::class2()
{
}

void class2::Init(struct1* data)
{
   // Consider moving this to the constructor and
   // removing this function from the class,
   // so that you don't need to always call Init()
   // after the creation of each and every object.
   cfg = data;
}


////////////////////////////////////////////////////////
// struct1.h - Put struct declaration here

#pragma once

class class2;

struct struct1
{
private:
   class2* item;

public:
   struct1();
};


////////////////////////////////////////////////////////
// struct1.cpp - Put struct implementation here

#include "struct1.h"
#include "class2.h"

struct1::struct1()
{
   item = new class2(); /* ERROR SHOULD NOT OCCUR HERE ANYMORE */
}


////////////////////////////////////////////////////////
// main.cpp

#include "class2.h"
#include "struct1.h"

void main()
{
   struct1* config;
   config->item = new class2();
   config->item->Init(config);
}

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown