二叉树(类模板、函数模板、函数对象、函数指针)

这个二叉树的代码只是简单的实现了一些功能，比如插入和遍历。关键是用到了函数指针和函数对象，还有shared_ptr。

其中shared_ptr一定定义在节点中，因为new出来的空间时节点，释放的时候是释放节点。

在函数模板中用到函数对象时，如果要传递的是函数指针则必须把函数名和要用的参数T传入，不能只传入函数名，注意这和调用函数模板是不一样。如果传递的是函数对象，需要向构造一个类，重载()，然后传入临时对象或者对象。

如果函数模板中用到的是函数指针，则传入时一定要加上T的实例化，否则编译时不会通过的。

#include<iostream>
#include<memory>
using namespace std;

template<typename T>
struct BinNode
{
	T data;
	shared_ptr<BinNode<T> > parent,lChild,rChild;
	BinNode():parent(NULL),lChild(NULL),rChild(NULL){}
	BinNode(T d,shared_ptr<BinNode<T> >p=NULL,shared_ptr<BinNode<T> >l=NULL,shared_ptr<BinNode<T> >r=NULL):data(d),parent(p),lChild(l),rChild(r){}
	~BinNode()
	{	cout<<"调用BinNode析构函数"<<endl;	}
};

template<typename T>
class BinTree
{
	int _size;
	shared_ptr<BinNode<T>> root;
public:
	BinTree():_size(0),root(NULL){}
	~BinTree()
	{	cout<<"调用析构函数"<<endl;	}//由于使用share_ptr，因此不需要进行delete
	int size() const
	{	return _size;	}
	bool empty() const
	{	return _size==0;	}
	shared_ptr<BinNode<T>> getRoot()
	{	return root;	}
	void insertAsLChild(BinNode<T> *parent,T const &e);
	void insertAsRChild(BinNode<T> *parent,T const &e);
	template<typename VST>//利用函数对象的访问
	void postOrderTrav(shared_ptr<BinNode<T>> root,VST &visit);
	void preOrderTrav(shared_ptr<BinNode<T>> root,void(*visit1)(T&));
	void BinTree<T>::inOrderTrav(shared_ptr<BinNode<T>> root);
};

template<typename T>
void BinTree<T>::insertAsLChild(BinNode<T> *parent,T const &e)
{
	shared_ptr<BinNode<T> > p(new BinNode<T>(e));
	if(parent==NULL)
		root=p;
	else
		parent->lChild=p;
	++_size;
}

template<typename T>
void BinTree<T>::insertAsRChild(BinNode<T> *parent,T const &e)
{
	shared_ptr<BinNode<T> > p(new BinNode<T>(e));
	if(parent==NULL)
		root=p;
	else
		parent->rChild=p;
	++_size;
}

template<typename T>
template<typename VST>
void BinTree<T>::postOrderTrav(shared_ptr<BinNode<T>> root,VST &visit)
{
	if(root==NULL)
		return ;
	postOrderTrav(root->lChild,visit);
	postOrderTrav(root->rChild,visit);
	visit(root.get()->data);
}

template<typename T>
class visit
{
public:
	void operator ()(T &data)
	{
		cout<<data<<endl;
	}
};

template<typename T>
void visitTheData(T &data)
{
	cout<<data<<endl;
}

template<typename T>
void BinTree<T>::preOrderTrav(shared_ptr<BinNode<T>> root,void(*visit1)(T&))
{
	if(root==NULL)
		return ;
	visitTheData(root.get()->data);
	preOrderTrav(root->lChild,visit1);
	preOrderTrav(root->rChild,visit1);
}

template<typename T>
void BinTree<T>::inOrderTrav(shared_ptr<BinNode<T>> root)
{
	if(root==NULL)
		return ;
	inOrderTrav(root->lChild);
	cout<<root.get()->data<<endl;
	inOrderTrav(root->rChild);
}

int main()  
{  
	BinTree<int> bt;
	bt.insertAsLChild(0,3);
	bt.insertAsLChild(bt.getRoot().get(),4);
	bt.insertAsRChild(bt.getRoot().get(),5);
	cout<<"后序遍历："<<endl;
	cout<<"函数对象："<<endl;
	bt.postOrderTrav(bt.getRoot(),visit<int>());//调用函数对象
	cout<<"函数指针作为函数对象传值："<<endl;
	bt.postOrderTrav(bt.getRoot(),visitTheData<int>);//调用函数指针为函数对象传值
	cout<<"先序遍历："<<endl;
	bt.preOrderTrav(bt.getRoot(),visitTheData<int>);//调用函数指针
	cout<<"中序遍历："<<endl;
	bt.inOrderTrav(bt.getRoot());

    system("pause");  
    return 0;  
}