c++指针中带->运算符看不来，

Question

部分代码：
class list
{
public:
list *head;
list *tail;
list *next;
int num;
list()
{ head=tail=next=null;}
}
class queue:public list{};
queue类中存储函数看不来，如下
void queue::store(int i)
{
list *item;
item=new queue;
item->num=i;
if(tail)
tail->next=item; //这里怎么看啊
tail=item;
item->next=NULL; //这里也看不懂
if(!head)
head=tail; //也不清楚
}

Answer 1

class list
{
public:
list *head;
list *tail;
list *next;
int num;
list()
{ head=tail=next=null;}
}
class queue:public list{};
queue类中存储函数看不来，如下
void queue::store(int i)
{
list *item;
item=new queue;
item->num=i;数据赋值
if(tail)
tail->next=item; //这里怎么看啊，解答：插入到表尾
tail=item; //另外：这里也很关键，新的数据在表的尾部，让尾指针指向新的表尾，
item->next=NULL; //这里也看不懂，解答：尾指针tail=item，item->next=NULL表示链表结束，
if(!head)
head=tail; //也不清楚，解答：如果插入前是空表，head==NULL，给头指针赋值
}

list 有三个指针 list *head，*tail，*next;
next 是实际的链表指针，head 永远指向表头，tail 永远指向表尾。
链表用 头尾指针来指示链表的存在，这个链表非常浪费空间，
插入新数据是分配一个新节点，
新数据插入表尾,tail->next=item;
tail 重新指向新数据 item(tail=item)
item->next=NULL;把新数据（新表尾的链表指针设为空，表示最后一个数据，方便查找）
如果插入前是空表，head =item，给头指针赋值为新数据（此时表内只有一个节点item）
head=tail，和head =item效果一样
实际上应修改如下比较好：

class list
{
private
struct node
{
node *next;
int num;
node():i(0),next(NULL){};
node(int i):next(NULL),num(i)
{
next =new node;
next->next=NULL;
};
node *insert(int i)
{
if(next==NULL)
{
next =new node;
next->next=NULL;}
else
{
next ->next =new node;
next->next=NULL;}
}
return next;
};
node *head,tail;

public:

node *head;
node *tail;
// list *next;
// int num;
list()
{ head=tail=null;}
void inserttail(int i)
{
if (!tail)tail=new node(i);
else tail = tail->insert(i);
if(head==NULL)head=tail;
};
class queue:public list{};

void queue::store(int i)
{
inserttail(i);
};
即，表和节点分开分别为list，node。 queue 继承自list，
这样，节点只有一个指针，表有表头表尾两个指针，所有链表代码都在list，node里，queue只负责queue类的新功能，结构比较清晰。
node，实现链表的插入，删除代码，list维护表头表尾两个指针，较为节省内存。
指向运算符的作用是简化(*p).d 为p->d 代码清楚并节省一个字符。
这里问题出在链表其实是用C做的，可是用C++封装代码时，把Node 和head，tail两个指针封装到一起了

Answer 2

queque是list类的子类，但没有增加任何新的东西，所以基本上二者是等价的，但对于某些编译器较严格的语法要求强制转换。
你说的那个地方，item是list类指针，并分配了queue即list类空间；tail本身是指针，它指向的对象的内部成员(public型)的访问必须使用“->”操作符。而next也是list类指针，所以tail->next=item;的意思就是把item指向的单元地址送给tail->next指针，这里list实际是要建立链表，且默认把新增的单元比如这里的item作为链表的最后一个单元(当前tail(不为空时)指针指向的下一单元的next指针指向这个新单元，且tail改为这个新单元地址，而这个新单元后面没有其他单元，因此item的next为NULL)。

从程序看，这是一个后进入尾的双向链表(当前面的单元head指向的不存在时，必须将其指向最后一个单元，实质上由构造函数初始化将head=tail=next=null;可知当链表中仅有一个单元时head=tail=item)。

追问

还是不能理解啊，tail和next不是同级的指针吗？用了成员指向符让我觉得tail也指向一个list的类空间，而next为这个类空间的成员指针，这个函数用来建立一个链表，我看不来如果输入i，他放哪里，怎么放了？

追答

关键这里是对指针概念的理解和掌握以及对于链表的实际单元都是临时分配(地址空间不连续)时如何将它们能够串起来！
就像猜谜一样，你只有找到至少一个单元(head或tail)时才能找到所有单元，那前提就是这一个单元必须具有其他相关的信息，这就是这里next的作用。
我前面写得不完全正确，这边链表实际上是单向链表，但提供了一个指向最后单元的地址。
本质上，既然指针是地址，它无所谓类型，你的list类完全可以这样写：
class list
{
public:
void *head;
void *tail;
void *next;
};
只是在后面的访问中必须进行强制转换，才能按list的结构(class实际上是struct的扩展)访问其中的成员。

Answer 3

tail, item, head 都是list类这个类型的指针，既然是指针就可以用->
然后next又是list这个类里面的公开成员，所以可以指针指过去。
head=tail就理解为普通的指针等号运算符操作就可以了