实现广义表的内部基本函数，创建，拷贝，清除，计算表深度及结点个数等函数。

代码如下：

#pragma once;
#include 
//表结点类型
enum NodeType
{
 HEAD,
 VALUE,
 SUB,
};
//表各结点的成员
struct GeneralizedNode
{
 NodeType _type;              //结点类型
 GeneralizedNode* _next;       //指向当前层的下一个结点的指针
 
 union
 {
  char _value;
  GeneralizedNode* _subLink;    //指向子表的指针
 };
 GeneralizedNode(NodeType type,char value);
};
//结点的构造函数
GeneralizedNode::GeneralizedNode(NodeType type = HEAD,char value = 0)
 :_type(type)
 ,_next(NULL)
{
 if(_type == VALUE)
  _value = value;
 else if(_type == SUB)
  _subLink = NULL;
}
//类——广义表
class GeneralizedList
{
public:
 GeneralizedList(const char* str);
 GeneralizedList(GeneralizedList& gl);
 GeneralizedList& operator=(GeneralizedList gl);
 ~GeneralizedList();
 void Print();
 int Size();
 int Depth();
protected:
 GeneralizedNode* _CreateList(const char*& str);
 void _Print(GeneralizedNode* head);
 GeneralizedNode* _Copy(GeneralizedNode* head);
 void _Clear(GeneralizedNode* head);
 int _Size(GeneralizedNode* head);
 int _Depth(GeneralizedNode* head);
protected:
 GeneralizedNode* _head;
};

//广义表的构造函数
GeneralizedList::GeneralizedList(const char* str)
{
 _head = _CreateList(str);
}
//创建广义表
GeneralizedNode* GeneralizedList::_CreateList(const char*& str)
{
 assert(*str == '(');
 GeneralizedNode* head = new GeneralizedNode(HEAD);
 GeneralizedNode* cur = head;
 str++;
 
 while(*str != '\0')
 {
  if((*str >= '0' && *str <= '9') || (*str >= 'A' && *str <= 'Z') || (*str >= 'a' && *str <= 'z'))
  {
   GeneralizedNode* val = new GeneralizedNode(VALUE,*str);
   cur->_next = val;
   cur = cur->_next;
  }
  else if(*str == '(')
  {
   GeneralizedNode* sub = new GeneralizedNode(SUB);
   sub->_subLink = _CreateList(str);
   cur->_next = sub;
   cur = cur->_next;
  }
  else if(*str == ')')
  {
   return head;
  }
  str++;
 }
 return head;
}
//广义表的拷贝构造函数
GeneralizedList::GeneralizedList(GeneralizedList& gl)
{
 _head = _Copy(gl._head);
}
//拷贝广义表
GeneralizedNode* GeneralizedList::_Copy(GeneralizedNode* head)
{
 GeneralizedNode* cur = head;
 GeneralizedNode* newHead = new GeneralizedNode(HEAD);
 GeneralizedNode* newCur = newHead;
 cur = cur->_next;
 while(cur != NULL)
 {
  if(cur->_type == VALUE)
  {
   GeneralizedNode* val = new GeneralizedNode(VALUE,cur->_value);
   newCur->_next = val;
  }
  else
  {
   GeneralizedNode* sub = new GeneralizedNode(SUB);
   sub->_subLink = _Copy(cur->_subLink);
   newCur->_next = sub;
  }
  newCur = newCur->_next;
  cur = cur->_next;
 }
 return newHead;
}
//广义表的赋值运算符重载函数
GeneralizedList& GeneralizedList::operator=(GeneralizedList gl)
{
 swap(gl._head,(*this)._head);
 /*if(this != &gl)
 {
  _Clear(_head);
  _head = _Copy(gl._head);
 }*/
 return *this;
}
//广义表的析构函数
GeneralizedList::~GeneralizedList()
{
 _Clear(_head);
}
//清除广义表
void GeneralizedList::_Clear(GeneralizedNode* head)
{
 GeneralizedNode* cur = head;
 while(cur != NULL)
 {
  GeneralizedNode* del = cur;
  if(cur->_type == SUB)
  {
   _Clear(cur->_subLink);
  }
  cur = cur->_next;
  delete del;
 }
 head = NULL;
}
//广义表的深度
int GeneralizedList::Depth()
{
 return _Depth(_head);
}
int GeneralizedList::_Depth(GeneralizedNode* head)
{
 GeneralizedNode* cur = head;
 int depth = 1;
 while(cur != NULL)
 {
  if(cur->_type == SUB)
  {
   if(_Depth(cur->_subLink)+1 > depth)
   {
    depth = _Depth(cur->_subLink)+1;
   }
  }
  cur = cur->_next;
 }
 return depth;
}
//广义表中值结点个数
int GeneralizedList::Size()
{
 return _Size(_head);
}
int GeneralizedList::_Size(GeneralizedNode* head)
{
 GeneralizedNode* cur = head;
 int count = 0;
 while(cur != NULL)
 {
  if(cur->_type == VALUE)
  {
   count++;
  }
  else if(cur->_type == SUB)
  {
   count += _Size(cur->_subLink);
  }
  cur = cur->_next;
 }
 return count;
}
//打印广义表
void GeneralizedList::Print()
{
 _Print(_head);
 cout<_next;
 while(cur != NULL)
 {
  if(cur->_type == VALUE)
  {
   cout<_value;
  }
  else if(cur->_type == SUB)
  {
   _Print(cur->_subLink);
  }
  if(cur->_next != NULL)
  {
   cout<<',';
  }
  cur = cur->_next;
 }
 cout<<')';
}