经验（2）c++前向声明及二叉树构造方法。

//树：
//树的遍历时的结点的设置
template<class Object>
struct TreeNode
{
	Object element;
	TreeNode *firstChild;
	TreeNode *nextSibling;
};

//后序遍历求文件大小
int FileSystem::size() const
{
	int totalSize = sizeofThisFile();

	if( isDirectory() )
		for(each each file c in this diretory (for each child))
			totalSize += c.size();

	return totalSize
}

积累：1.平均二叉树的深度要比结点个数N小得多

2. 记住这种构造函数的方法：（这叫做引址调用来传递指针变量的技术）

void create();  
bool create(BinaryNode *T);  //define 构造二叉树  //递归创建

其中

private:
BinaryNode *root;  

重点看下方：

bool BinaryTree::create(BinaryNode *T)
{
cout << "enter the value of the elem:";
Object x;
cin >> x;
if(x == '#') T = NULL;
else
{
T = new BinaryNode;
T->elem = x;
create(T->leftChild);
create(T->rightChild);
}
return true;
}

void BinaryTree::create()
{
create(root);
}

3. c++ 前向声明

http://blog.csdn.net/fjb2080/article/details/5533514 这个讲的是前向声明不需要重新编译，因为只是引用或指针（告诉我们使用另一个类对象时，声明而且只能声明为指针！！！！）

明白了一点：如果类A的声明中将另一个类B的成员函数声明为友元函数F，那么类A必须事先知道类B的定义；类B的成员函数F声明如果使用类A作为形参，那么也必须知道类A的定义，那么两个类就互相依赖了。

(1)

class B

class A

{

friend void B::b();

}

(2)

class A

class B

{

private:

A *a;

}

恍然大悟：

对于

（1）前些天写的一个友元类的调用：

class ChainNode  
{  
	friend class chain;   //friend class,the class chain can use the param of ChainNode  
	private:  
	int data;  
	ChainNode *link;  
};  
    
class chain    
{    
private:    
	ChainNode *first;  
	ChainNode *last;  
public:    
	chain(){ first  = last = 0; } //相当于InitList    
	~chain();  
	bool ListEmpty()const {return first == 0;}  //检查是否为empty    
	int Length()const;  //the length of the chain  
    bool find(int num, int &x) const; //查看特定位置元素    
    int Search (const int &e);  //返回e 的位置     
    chain& ListInsert(int num, const int& e);  //插入数据元素e, 在num的位置    
    chain& ListDelete(int num, int &x);  //删除the place元素,and 赋值, 并返回这个chain    
	chain& Append(const int &e); //结尾添加元素  
    void displayElem(ostream &out)const;  //遍历  //应该是输出到这个 ostream &out 里面。  
	friend ostream & operator << (ostream & out, chain& rs); //友元函数的应用  
};

没有问题，完全可以通过，因为ChaiNode中的类型的大小完全了解，这样在chain中使用的时候，会给分配特定的数据结构的大小，比如data,   这样可以直接不用前向声明；

而对于

template<class Object>
class BinaryNode;

template<class Object>
class BinaryTree
{
private:
	BinaryNode<Object> *root;   //想要对private进行创建，建立一个重载的函数
public:
	BinaryTree()
	{
		root = 0;
	}
	~BinaryTree(){}
	void create();  
	bool create(BinaryNode *T);  //define 构造二叉树  //递归创建
	
	//先序，中序，后序，只是输出顺序不同，在操作中递归排列输出顺序。
	void preOrderTraverse();
	void inOrderTraverse();
	void postOrderTraverse();
	void levelOrderTraverse();
	bool preOrderTraverse(BinaryNode *T);   //还可以将遍历完的结点加入到队列中，最后输出。这样就遍历完毕
	bool inOrderTraverse(BinaryNode *T);
	bool postOrderTraverse(BinaryNode *T);
	bool levelOrderTraverse(BinaryNode *T);

};
//typedef char Object;
template<class Object>
class BinaryNode
{
	friend class BinaryTree<Object>;
private:
	Object elem;
	BinaryNode *leftChild;
	BinaryNode * rightChild;
};

必须要进行前向声明，因为这是的Object 的大小是不确定的，所以前向声明，我们是要用的root = 0;用到了BinaryNode 的其中的大小，即BinaryTree中的方法提到了BinaryNode的对象，这样 BinaryNode的定义必须放在BinaryTree前面，并且friend class BinaryTree<Object>;整个类在BinaryNode声明，也应放在前面，因此加了前向声明。

网友验证：这两个是编译器的问题，推荐大家使用第二种！Ok~!