tree

#include <string>

#include <vector>

#include <iostream>

 

using namespace std;

 

class myTree

{

public:

string _type;

string _name;

vector<myTree*> _tree;

};

 

void buildTree(myTree& aTree)

{

aTree._name = "集团";

aTree._type = "集团";

 

myTree* pTreeCompony = NULL;

myTree* pTreeSubCompony = NULL;

myTree* pTreeDepartment = NULL;

myTree* pTreeTeam = NULL;

 

pTreeCompony = new myTree();

pTreeCompony->_name = "公司A";

pTreeCompony->_type = "公司";

aTree._tree.push_back(pTreeCompony);

pTreeSubCompony = new myTree();

pTreeSubCompony->_name = "子公司1";

pTreeSubCompony->_type = "子公司";

pTreeCompony->_tree.push_back(pTreeSubCompony);

 

pTreeSubCompony = new myTree();

pTreeSubCompony->_name = "子公司2";

pTreeSubCompony->_type = "子公司";

pTreeCompony->_tree.push_back(pTreeSubCompony);

 

pTreeSubCompony = new myTree();

pTreeSubCompony->_name = "子公司3";

pTreeSubCompony->_type = "子公司";

pTreeCompony->_tree.push_back(pTreeSubCompony);

 

pTreeCompony = new myTree();

pTreeCompony->_name = "公司B";

pTreeCompony->_type = "公司";

aTree._tree.push_back(pTreeCompony);

 

pTreeCompony = new myTree();

pTreeCompony->_name = "公司C";

pTreeCompony->_type = "公司";

aTree._tree.push_back(pTreeCompony);

 

}

 

void PrintTree(const myTree& aTree)

{

static int n = 0;

for (int i = 0;i < n;++i)

{

cout << " ";

}

cout << aTree._name << endl;

 

for (vector<myTree*>::const_iterator iter = aTree._tree.begin();

iter != aTree._tree.end();

++iter)

{

++n;

PrintTree( **iter );

}

--n;

}

 

class Base

{

 

};

 

class SubCompany : public Base

{

public:

SubCompany()

{

 

}

SubCompany(string name)

:_name(name)

{

 

}

string _name;

};

 

 

 

class Company : public Base

{

public:

Company()

{

 

}

Company(string name)

:_name(name)

{

 

}

string _name;

vector<Base*> _vec;

};

 

class Group : public Base

{

public:

Group(string name)

:_name(name)

{

 

}

string _name;

vector<Base*> _vec;

};

 

template<class A>

A*  convert(myTree* node)

{

A* parent = new A(node->_name);

for (vector<myTree*>::const_iterator iter = node->_tree.begin();

iter != node->_tree.end();

++iter)

{

if( node->_type == "集团" )

{

parent->_vec.push_back(convert<Company>(*iter));

}

else if( node->_type == "公司" )

{

SubCompany* pSubCompany = new SubCompany( (*iter)->_name ) ;

parent->_vec.push_back(pSubCompany );

}

//if( node._type == "子公司" )

// parent._vec.push_back(convert<部门>(*iter));

}

 

return parent;

}

 

//对最低级别的做模板特化

//template<class  SubCompany >

//SubCompany*  convert(myTree* node)

//{

// return new SubCompany ();

//}

 

 

 

 

void main()

{

myTree aTree;

buildTree(aTree);

PrintTree(aTree);

 

//最后调用

Group* pGroup = convert<Group>(&aTree);

 

for (vector<Base*>::iterator iter = pGroup->_vec.begin();

iter != pGroup->_vec.end();

++iter)

{

Company* pCompany = static_cast<Company*>(*iter);

cout << "\n\n";

cout << pCompany->_name << endl;

 

for (vector<Base*>::iterator iter = pCompany->_vec.begin();

iter != pCompany->_vec.end();

++iter)

{

SubCompany* pSubCompany = static_cast<SubCompany*>(*iter);

cout << " ";

cout << pSubCompany->_name << endl;

 

 

}

}

}

 

;