C / C++ / MFC

struct A;
struct B;

struct A
{
  int lolipops;
  B* candy;

  A(B* ptr);

  void action(int pass);
};

struct B{
 int gums;
 A* candy;
 
 B(A* ptr);

 void action(int pass);
};

//forward decl
struct A;
struct B;

struct A
{
 int lolipops;
 B* candy;
 A(B* ptr)
 {
   lolipops = 0;
   candy = ptr;
 }  

 action(int pass)
 {
    candy->gums = pass;
 }
};

struct B
{
 int gums;
 A* candy;

 B(A* ptr)
 {
  gums = 0;
  candy = ptr;
 }

 action(int pass)
 {
   candy->lolipops = pass;//this is where i get the error of undefined type 'A' 
 }
};

struct A;
struct B;

struct A
{  
	int lolipops;  
	B* candy;  
	A(B* ptr);  
	void action(int pass);
};

struct B
{ 
	int gums;
	A* candy;  
	B(A* ptr); 
	void action(int pass);
};

#include "base.h"

A::A(B* ptr)
{

}

void A::action(int pass)
{
	candy->gums = pass;
}

B::B(A* ptr)
{
	candy = ptr;
}

void B::action(int pass)
{
	candy->lolipops = pass;
}

struct A;
struct B;

struct A
{  
	int lolipops;  
	B* candy;  
	A(B* ptr) {}  
	inline void action(int pass);
};

struct B
{ 
	int gums;
	A* candy;  
	B(A* ptr) {}
	inline void action(int pass);
};


inline void A::action(int pass)
{
	candy->gums = pass;
}

inline void B::action(int pass)
{
	candy->lolipops = pass;
}

struct A;               // 'A' is a symbol used to declare a struct type some time later
struct B;               // same for 'B'
struct A {              // here starts the declaration of A (this makes the forward declaration of A redundant!)
   int gummy;
   B* myb;              // this is a pointer - since all pointers are of same size, no need to more about B here
   A() : myb(0) {}      // initialize a pointer to an unknown type to 0 is not a problem either
   void set(B* b) {
      myb = b;          // again no problem - a pointer is a pointer is a pointer
      gummy = b->bears; // error: compiler does not know about bears at this point!
   }
};
struct B {
   int bears;           // now, had the compiler only known about this before ...
   A* mya;              // ok, just a pointer here
   B() : mya(0) {}      // same boring stuff
   void set(A* a) {
      mya = a;          // pointer stuff, no worries
      bears = a->gummy; // error: compiler hasn't seen a *valid* declaration of struct A yet, and thus doesn't know about gummy
   }
};

struct B;               // forward declaration for 'B' (none needed for A)
struct A {              // here starts the declaration of A (this makes the forward declaration of A redundant!)
   int gummy;
   B* myb;              // this is a pointer - since all pointers are of same size, no need to more about B here
   A() : myb(0) {}      // initialize a pointer to an unknown type to 0 is not a problem either
   void set(B* b);      // ok: just a prototype declaration, using a pointer to an as of yet undefined struct
};          // end of declaration of struct A: from now on, the compiler knows the full scope of A!
struct B {
   int bears;
   A* mya;              // ok, just a pointer here
   B() : mya(0) {}      // same boring stuff
   void set(A* a) {
      mya = a;          // pointer stuff, no worries
      bears = a->gummy; // ok: compiler has seen the declaration of struct A, and thus knows about gummy
   }
};          // end of declaration of struct B: from now on, the compiler knows the full scope of B!
void A::set( B* b )
{
   myb = b;          // pointers again
   gummy = b->bears; // ok: compiler now knows about bears at this point!
}

Your::Your ()
: My (42)
{
}

Your::Your ()
: My [0](42), My [1](420), My [2](3)
{
}

My my[] = {3,5,11}; // correct: this will invoke My::My(int) for each member
My my3[3] = {3,5,11}; // correct: predetermined array size sorresponds to size of initializer list
My my4[4] = {3,5,11}; // error: elements of partially initialized array must have default constructor

class My {
   int val;
public:
   My(int i) : val(i) {}
   int get() const {return val;}
};
class Your {
   char myPlaceHolder[3][sizeof(My)];
   My* my;
public:
   Your()
   { 
      my = (My*)(myPlaceHolder); // just to assign the address
      new (&my[0]) My(3);         // calls My::My(int) in-place using the memory allocated at myPlaceHolder[0]
      new (&my[1]) My(5);
      new (&my[2]) My(11);
   }
   int operator[](int i) const { return my[i].get(); }
};
void testYour() {
   Your your;
   std::cout << "my[0]="<<your[0] << " ; my[1]="<<your[1] << " ; my[2]=" <<your[2] << std::endl;
}