大家经常会碰到这样的问题:定义一个数据类型，而此数据类型又包含此数据类型的变量。通常做法应该是把数据类型中的变量定义为指针形式。例如定义一个二叉树的节点:
struct tagNode //二叉树节点
{
ElemType data; //节点数据
struct tagNode *pLeftNode; //节点左孩子
struct tagNode *pRightNode; //节点右孩子
}上述二叉树节点定义是正确的，可以编译通过。但如果定义为下述对象形式，则无法编译通过:
struct tagNode //二叉树节点
{
ElemType data; //节点数据
struct tagNode LeftNode; //节点左孩子
struct tagNode RightNode; //节点右孩子
} 然而上述对象形式的二叉树节点为何不能编译通过，而采用指针形式的二叉树节点可以编译通过呢?
答案是 C/C++采用静态编译模型。程序运行时，结构大小会在编译后确定。程序编LeftNode.LeftNode.LeftNode..-.这类错误也称为类和结构的递归定义错误。要正确编译，编译器必须知道一个结构所占用的空间大小。除此之外还有一个逻辑方面的问题，在这种情况下，想想可以有LeftNode.LeftNode.LeftNode.LeftNode.
如果采用指针形式，指针的大小与机器的字长有关，不管是什么类型，编译后指针的大小总是确定的，所以这种情况下不需要知道结构 struct tagNode 的确切定义。例如，在32 位字长的 CPU 中，指针的长度为 4 字节。所以，如果采用指针的形式，structtagNode的大小在其编译后即可确定,为sizeof(int)+4+4.对于对象形式的 struct tagNode定义，其长度在编译后是无法确定的。
注意:
(1) 在Visual studio 2010编译器中，错误C2460代表这种递归定义错误，编译提示:”identifier1″:使用正在定义的”identifier2″，将类或结构(identifier2)声明为其本身的成员(identifier1)，不允许类和结构的递归定义。
(2) 在编程过程中，禁止类和结构的递归定义，以防产生奇怪的编译错误。现在，我们继续讨论类递归定义的经典案例一两个类相互包含引用问题。这是所有 C++程序员都会碰到的经典递归定义案例。
案例:CA 类包含 CB类的实例，而 CB类也包含 CA 类的实例。代码实现如下:
//A.h实现CA类的定义
#include"B.h"
class CA
{
Public:
intiData; //定义int数据iData
CB instanceB: //定义CB 类实例instanceB
}
//B.h实现CB类的定义
#include"A.h"
class CB
{
public:
int iData; //定义int数据iData
CAinstanceA; //定义CA 类实例instanceA
}
int main()
{
CAinstanceA;
return 0;
}上述代码在VisualC 2010上无法编译通过，编译器会报出 C2460 错误。先分析一下代码存在的问题:
● CA类定义时使用CB类的定义，CB类定义时使用CA类的定义，递归定义。
● A.h包含了B.h，B.h 包含了A.h，也存在递归包含的问题。
其实，无论是结构体的递归定义，还是类的递归定义，最后都归于一个问题C/C++采用静态编译模型。在程序运行时，结构或类大小都会在编译后确定。程序要正确编译，编译器必须知道一个结构或结构所占用的空间大小，否则编译器就会报出奇怪的编译错误，如C2460错误。
最后,我们给出类或结构体递归定义的几个经典解法。这里以类为例，因为在C++中 struct也是class，class举例具有通用性。
1.前向声明实现
//A.h实现CA类的定义
class CB;//前向声明CB类
class CA
{
public:
Int iData; //定义int数据iData
CB*pinstanceB; //定义 CB类的指针 pinstanceB
}
//B.h实现CB类的定义
#include "A.h"
class CB
{
public:
Int iData; //定义int数据iData
CAinstanceA; //定义 CA类实例instanceA
}
#include"B.h"
int main()
{
CA instanceA;
return 0;
}前向声明实现方式的主要实现原则:
●主函数只需要包含 B.h就可以，因为 B.h 中包含了A.h。
●A.h 中不需要包含 B.h，但要声明 class CB，在避免死循环的同时也成功引用了CB。
●包含class CB 声明，而没有包含头文件 B.h，这样只能声明 CB类型的指针，而不能实例化。
2.friend声明实现
//A.h实现CA类的定义
class CA
{
public:
friend class CB; /友元类声明
int iData; //定义int数据iData
CB *pinstanceB; //定义CB类的指针 pinstanceB
}
//B.h实现CB类的定义
#include "A.h"
class CB
{
public:
int iData; //定义int数据iData
CAinstanceA; //定义 CA类实例 instanceA
}
#include"B.h"
int main()
{
CA instanceA;
return 0:
}friend友元声明实现说明:
● 主函数只需要包含B.h就可以，因为B.h中包含了A.h。
● A.h 中不需要包含B.h，但要声明class CB，在避免死循环的同时也成功引用了CB。
● class CA 包含class CB友元声明，而没有包含头文件 B.h，这样只能声明 CB类型的指针，而不能实例化。
不论是前向声明实现还是friend友元实现，有一点是肯定的:即最多只能有一个类可以定义实例。同样头文件包含也是一件很麻烦的事情，再加上头文件中常常出现的宏定义，感觉各种宏定义的展开是非常耗时间的。类或结构体递归定义实现应遵循两个原则:
(1) 如果可以不包含头文件，那就不要包含了。这时候前置声明可以解决问题。如果使用的仅仅是一个类的指针，没有使用这个类的具体对象(非指针)，也没有访问到类的具体成员，那么前置声明就可以了。因为指针这一数据类型的大小是特定的，编译器可以获知。
(2) 尽量在CPP文件中包含头文件，而非在头文件中。假设类A的一个成员是一个指向类B的指针，在类A的头文件中使用了类B的前置声明并编译成功，那么在A的实现中需要访问B的具体成员，因此需要包含头文件，那么我们应该在类A的实现部分(CPP文件)包含类 B的头文件而非声明部分。
请谨记
● 类和结构体定义中禁止递归定义，以防产生奇怪的编译错误。如果两个类相互递归定义时，需考虑前向声明或friend友元实现。但无论通过何种方法实现，有一点是肯定的:即最多只能有一个类可以定义实例。
