C / C++ / MFC

Craig Longman wrote:

I just lost ALL the target specific settings for all 6 projects in my solution because I had to add _CRT_SECURE_NO_WARNINGS to all targets/configs.

Craig Longman wrote:

it simply removes all the current directives and replaces it with what I typed in.

Craig Longman wrote:

I looked, but the closest I saw was this one having a description of "C, Visual C++

Richard MacCutchan wrote:

Hmmm, I would have thought that "Visual Studio" is closest; this question has almost nothing to do with C, C++ or 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!
}