->叫做结构体指针运算符，也是用来访问结构体内部成员的。换种说法，如果我们在C语言中定义了一个结构体，然后声明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.
举个例子：

struct Data
{
int a,b,c;
}; /*定义结构体类型*/
struct Data * p;                 /*  定义结构体指针   */
struct Data A = {1,2,3};         / *  声明结构体变量A，A即结构体名   */
int x;                               /*  声明一个变量x  */
p = &A ;                           /*   地址赋值，让p指向A    */
x = p->a;        /* 取出p所指向的结构体中包含的数据项a赋值给x   */
/* 此时由于p指向A，因而 p->a == A.a,也就是1 */

因为此处p 是一个指针，所以不能使用.号访问内部成员(即不能p.a)，而要使用->。但是A.a是可以的，因为A不是指针，是结构体名。

一般情况下用“.”只需要声明一个结构体。格式是：结构体类型名+结构体名。然后用结构体名加“.”加成员名就可以引用成员了。因为自动分配了结构体的内存。如同 int a;一样。

用“->”，则要声明一个结构体指针，还要手动开辟一个该结构体的内存（上面的代码则是建了一个结构体实例，自动分配了内存，下面的例子则会讲到手动动态开辟内存），然后把返回的地址赋给声明的结构体指针，才能用“->”正确引用。否则内存中只分配了指针的内存，没有分配结构体的内存，导致想要的结构体实际上是不存在。这时候用“->”引用自然出错了，因为没有结构体，自然没有结构体的域了。

此外，（*p）.a 等价于 p->a。

而对于 p = p->next;这应该出现在C语言的链表，其中的next应该是自定义的一个与p同类型的结构体指针，定义格式为：

struct Data 
{
   int a;
   struct Data * next;
};/*定义结构体*/
…………
main()
{
   struct Data * p;/*声明指针变量p*/
  ……
   p = p->next;/*将next中的值赋给p*/
}

以下是参考《啊哈！算法》中的链表中的每一个结点应该如何存储（我的理解是结点就类似java等面向对象编程中的实例对象）

如上图，每一个结点都由两个部分组成。左边的部分用来存放具体的数值，那么用一个整型变量就可以；右边的部分需要存储下一个结点的地址，可以用指针来实现（也称为后继指针）。

这里我们定义一个结构体类型来存储这个结点，如下。

struct node
{
	 int data;
	struct node *next;
};

上面代码中，我们定义了一个叫做node 的结构体类型，这个结构体类型有两个成员。第一个成员是整型data，用来存储具体的数值；第二个成员是一个指针，用来存储下一个结点的地址。因为下一个结点的类型也是struct node，所以这个指针的类型也必须是struct node* 类型的指针。

如何建立链表呢？首先我们需要一个头指针head 指向链表的最开始。当链表还没有建立的时候头指针head 为空（也可以理解为指向空结点）。

struct node *head;
head = NULL;//头指针初始为空

现在我们来创建第一个结点，并用临时指针p 指向这个结点。

struct node *p;
//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
p=(struct node *)malloc(sizeof(struct node));

接下来分别设置新创建的这个结点的左半部分和右半部分。

scanf("%d",&a);
p->data=a;//将数据存储到当前结点的data域中
p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空

下面来设置头指针并设置新创建结点的*next 指向空。头指针的作用是方便以后从头遍历整个链表。

if(head==NULL)
head=p;//如果这是第一个创建的结点，则将头指针指向这个结点
else
q->next=p;//如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点

如果这是第一个创建的结点，则将头指针指向这个结点。

如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点。

最后要将指针q 也指向当前结点，因为待会儿临时指针p 将会指向新创建的结点。

q=p;//指针q也指向当前结点

当然，完整的代码是下面的那样子：

#include <stdio.h>
#include <stdlib.h>
//这里创建一个结构体用来表示链表的结点类型
struct node
{
	int data;
	struct node *next;
};
int main()
{
	struct node *head,*p,*q,*t;
	int i,n,a;
	scanf("%d",&n);
	head = NULL;//头指针初始为空
	for(i=1;i<=n;i++)//循环读入n个数
	{
		scanf("%d",&a);
	//动态申请一个内存空间，用来存放一个结点，并用临时指针p指向这个结点
		p=(struct node *)malloc(sizeof(struct node));
		p->data=a;//将数据存储到当前结点的data域中
		p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空
		if(head==NULL)
			head=p;//如果这是第一个创建的结点，则将头指针指向这个结点
		else
			q->next=p;//如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点
		q=p;//指针q也指向当前结点
}
//输出链表中的所有数
		t=head;
	while(t!=NULL)
	{
		printf("%d ",t->data);
		t=t->next;//继续下一个结点
	}
	getchar();getchar();
	return 0;
}

需要说明的一点是：上面这段代码没有释放动态申请的空间，虽然没有错误，但是这样会很不安全，有兴趣的朋友可以去了解一下free 命令。

-> 是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.

举个例子：

struct Data

{

int a,b,c;

}; /*定义结构体*/

struct Data * p;/*定义结构体指针*/

struct Data A = {1,2,3};/*声明变量A*/

int x;/*声明一个变量x*/

p = &A ; /*让p指向A*/

x = p->a;/*这句话的意思就是取出p所指向的结构体中包含的数据项a赋值给x*/

/*由于此时p指向A，因而 p->a == A.a,也就是1*/

对于 p = p->next;这应该出现在C语言的链表，这里的next应该是一个与p同类型的结构体指针，其定义格式应该是：

struct Data

{

int a;

struct Data * next;

};/*定义结构体*/

…………

main()

{

struct Data * p;/*声明指针变量p*/

……

p = p->next;/*将next中的值赋给p*/

}

链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。

扩展资料：
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。

每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。

由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。

链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。

链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。

程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表。

参考资料：链表–百度百科

 ->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.

举个例子：
struct Data
{
   int a,b,c;
};              /*定义结构体*/
struct Data * p;/*定义结构体指针*/
struct Data A = {1,2,3};/*声明变量A*/
int x;/*声明一个变量x*/
p = &A ; /*让p指向A*/
x = p->a;/*这句话的意思就是取出p所指向的结构体中包含的数据项a赋值给x*/
         /*由于此时p指向A，因而 p->a == A.a,也就是1*/

对于一开始的问题 p = p->next;这应该出现在C语言的链表，这里的next应该是一个与p同类型的结构体指针，其定义格式应该是：
struct Data 
{
   int a;
   struct Data * next;
};/*定义结构体*/
…………
main()
{
   struct Data * p;/*声明指针变量p*/
  ……
   p = p->next;/*将next中的值赋给p*/
}


    链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。

    什么是变量？所谓变量，不要浅显的认为会变得量就是变量。套用我们院长的问话：“教室变不变？”变，因为每天有不同的人在里面上课，但又不变，因为教室始终在那，没有变大或变小。这就是变量：有一个不变的地址和一块可变的存储空间。正常情况下，我们只看到变量这个房间里面的东西，也就是其内容，但不会关注变量的地址，但是C语言的指针，就是这个房间的地址。我们声明变量就相当于盖了间房子存放东西，我们可以直接观看房子里的东西，而声明指针，就是相当于获得了一个定位器，当用指针指向某个变量时，就是用指针给变量定位，以后我们就可以用指针找到他所“跟踪”的变量并可以获得里面的内容。
那结构体呢？结构体就相当于是有好几个房子组成的别墅，几个房子绑定在一起使用。假设现在有很多这种别墅分布在一个大迷宫里，每间别墅里都有一间房子。里面放了另一个别墅的位置信息，现在你手拿定位器找到了第一栋别墅，从里面得到了你想要的东西（链表的数据部分）,然后把下一栋别墅的位置计入你的定位器（p = p->next），再走向下一栋别墅……如此走下去，知道走到某地下一栋别墅信息没有了（p->next == NULL），你的旅行结束。这就是链表一次遍历的过程。现在你能明白 p=p->next的含义了吧！
写了这么多。希望你能明白。

    如果想学好c和C++，链表和指针必须熟练掌握！