c++向前声明解决循环引用问题，简化依赖关系

两个类A和B相互关联，相互引用，如果采用彼此包含对方头文件的方式会出现循环引用，所以采用了类的前置声明的方式

1. class A采用前置声明的方式声明class B
2. 在Class B的头文件中包含class A 的头文件
3. 在Class A中只能声明class B类型的指针或者引用
4. Class A.cpp中包含Class B 的头文件，实现时可以正常使用指针和引用

前置声明（向前声明）

可以声明一个类而不定义它，这个声明被称为前向声明(forward declaration)。
在声明之后，定义之前，类是一个不完全类型(incompete type)，即已知向前声明过的类是一个类型，但不知道包含哪些成员。
不完全类型只能以有限方式使用，不能定义该类型的对象，不完全类型只能用于定义指向该类型的指针及引用，或者用于声明(而不是定义)使用该类型作为形参类型或返回类型的函数

//A.h

#pragma once
class B;//前置声明
class A
{
public:
	A();
	A(class B* pB);
	~A();
 
public:
	void displayA();
	void invokeClassBInClassA();
private:
	class B *mB;
};
 

//A.cpp

#include "A.h"
#include "B.h"
#include 
using namespace std;
 
 
A::A()
{
}
 
A::A(B * pB)
{
	mB = pB;
}
 
 
A::~A()
{
}
 
 
void A::displayA()
{
	cout << "this is A" << endl;
}
 
 
void A::invokeClassBInClassA()
{
	cout << "class A invoke class B starts>>" << endl;
	mB->displayB();
}

//B.h


#pragma once
#include "A.h"
 
class B
{
public:
	B();
	~B();
 
public:
	void displayB();
	void invokeClassAInClassB();
private:
	class A * mA;
};
 

//B.cpp
    
    
#include "B.h"
#include 
using namespace std;
 
 
B::B()
{
	mA = new A();
}
 
 
B::~B()
{
}
 
void B::displayB()
{
	cout << "this is the B" << endl;
}
 
void B::invokeClassAInClassB()
{
	cout << "class B invoke class A starts >>" << endl;
	mA->displayA();
}

 
#include 
#include "A.h"  
#include "B.h"
using namespace std;
 
 
 
int main()
{
	cout << "----------main starts---------------" << endl;
	class B* pB = new B();
	class A* pA = new A(pB);
 
	pA->displayA();
	pA->invokeClassBInClassA();
 
	
	pB->displayB();
	pB->invokeClassAInClassB();
 
	cout << "----------main  ends----------------" << endl;
	return 0;
}