结构体指针

结构体与指针

1.结构体指针的数值为某个结构体的内存空间的地址，从而指针指向某个结构体。

2.结构体指针的初始值为空(0)，不指向任何结构体。

3.malloc操作：创建一个新的内存空间(从内存中选择一个内存空间存储结构体)，p指向这个结构体，p的值为这个结构体的内存空间的地址。

4.结构体指针的赋值：一个结构体指针的数值等于另外一个结构体指针的数值，从而两个结构体指针指向相同的结构体。当对某个结构体进行访问时，选择的结构体指针只要满足该结构体指针指向这个结构体即可，即可以有很多种选择。

5.当需要存储不同的内容，用到同一个结构体指针时，则需要改变结构体指针的数值，即指向不同的结构体，从而达到使用不同的结构体存储内容的目的，这里要用到malloc和#include<malloc.h>。

6.结构体内的某个变量所在的内存单元的地址=结构体所在的内存单元的地址+偏移地址(在结构体中的位置)。

7.通过结构体指针s内的结构体指针s->next，可以到达另外一个结构体指针t，从而可以访问结构体指针t所指向的结构体。

Code：

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <malloc.h>
 4  
 5 struct node
 6 {
 7     long value;
 8     struct node *next;
 9 }*s,*t;
10  
11 int main()
12 {
13     //1.结构体指针的数值为某个结构体的内存空间的地址，从而指针指向某个结构体
14  
15     //2.结构体指针的初始值为空(0)，不指向任何结构体
16     if (s==NULL)
17         printf("s=NULL\n");
18     printf("\n");
19  
20     //3.malloc操作：创建一个新的内存空间(从内存中选择一个内存空间存储结构体)，p指向这个结构体，
21         //p的值为这个结构体的内存空间的地址
22     printf("s=%ld\n",s);
23     s=(struct node *) malloc (sizeof(struct node));
24     printf("s=%ld\n",s);
25     s=(struct node *) malloc (sizeof(struct node));
26     printf("s=%ld\n",s);
27     printf("\n");
28  
29     //4.结构体指针的赋值：一个结构体指针的数值等于另外一个结构体指针的数值，从而两个结构体指针指向相同的结构体
30         //当对某个结构体进行访问时，选择的结构体指针只要满足该结构体指针指向这个结构体即可，即可以有很多种选择
31     t=s;
32     printf("t=%ld\n",t);
33     s->value=1;
34     printf("s->value=%ld\n",s->value);
35     printf("t->value=%ld\n",t->value);
36     printf("\n");
37  
38     //5.当需要存储不同的内容，用到同一个结构体指针时，则需要改变结构体指针的数值，即指向不同的结构体，
39         //从而达到使用不同的结构体存储内容的目的，这里要用到malloc和#include<malloc.h>
40     s=(struct node *) malloc (sizeof(struct node));
41     s->value=1;
42     t=s;
43     s=(struct node *) malloc (sizeof(struct node));
44     s->value=2;
45     printf("Previous value=%ld\n",t->value);
46     printf("Following value=%ld\n",s->value);
47     printf("\n");
48  
49     //6.结构体内的某个变量所在的内存单元的地址=结构体所在的内存单元的地址+偏移地址(在结构体中的位置)
50     printf("%ld\n",s);
51     printf("%ld\n",&(s->value));
52     printf("%ld\n",&(s->next));
53     printf("\n");
54  
55     //7.通过结构体指针s内的结构体指针s->next，可以到达另外一个结构体指针t，
56         //从而可以访问结构体指针t所指向的结构体
57     t=(struct node *) malloc (sizeof(struct node));
58     s->next=t;
59     printf("s->next=%ld\n",s->next);
60     printf("t=%ld\n",t->next);
61     printf("\n");
62  
63     return 0;
64 }

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <malloc.h>
 4  
 5 struct node
 6 {
 7     long value;
 8     struct node *next;
 9 }*s,*t;
10  
11 int main()
12 {
13     //1.结构体指针的数值为某个结构体的内存空间的地址，从而指针指向某个结构体
14  
15     //2.结构体指针的初始值为空(0)，不指向任何结构体
16     if (s==NULL)
17         printf("s=NULL\n");
18     printf("\n");
19  
20     //3.malloc操作：创建一个新的内存空间(从内存中选择一个内存空间存储结构体)，p指向这个结构体，
21         //p的值为这个结构体的内存空间的地址
22     printf("s=%ld\n",s);
23     s=(struct node *) malloc (sizeof(struct node));
24     printf("s=%ld\n",s);
25     s=(struct node *) malloc (sizeof(struct node));
26     printf("s=%ld\n",s);
27     printf("\n");
28  
29     //4.结构体指针的赋值：一个结构体指针的数值等于另外一个结构体指针的数值，从而两个结构体指针指向相同的结构体
30         //当对某个结构体进行访问时，选择的结构体指针只要满足该结构体指针指向这个结构体即可，即可以有很多种选择
31     t=s;
32     printf("t=%ld\n",t);
33     s->value=1;
34     printf("s->value=%ld\n",s->value);
35     printf("t->value=%ld\n",t->value);
36     printf("\n");
37  
38     //5.当需要存储不同的内容，用到同一个结构体指针时，则需要改变结构体指针的数值，即指向不同的结构体，
39         //从而达到使用不同的结构体存储内容的目的，这里要用到malloc和#include<malloc.h>
40     s=(struct node *) malloc (sizeof(struct node));
41     s->value=1;
42     t=s;
43     s=(struct node *) malloc (sizeof(struct node));
44     s->value=2;
45     printf("Previous value=%ld\n",t->value);
46     printf("Following value=%ld\n",s->value);
47     printf("\n");
48  
49     //6.结构体内的某个变量所在的内存单元的地址=结构体所在的内存单元的地址+偏移地址(在结构体中的位置)
50     printf("%ld\n",s);
51     printf("%ld\n",&(s->value));
52     printf("%ld\n",&(s->next));
53     printf("\n");
54  
55     //7.通过结构体指针s内的结构体指针s->next，可以到达另外一个结构体指针t，
56         //从而可以访问结构体指针t所指向的结构体
57     t=(struct node *) malloc (sizeof(struct node));
58     s->next=t;
59     printf("s->next=%ld\n",s->next);
60     printf("t=%ld\n",t->next);
61     printf("\n");
62  
63     return 0;
64 }

易错点：

1.创建结构体指针后(初始时结构体指针为空)，没有初始化，直接使用。

1 struct node
2 {
3     long value;
4     struct node *next;
5 }*s;
6  
7 s->value=1;

2.使用相同的指针访问结构体，即使用相同的结构体存储数值

 1 struct node
 2 {
 3     long value;
 4     struct node *next;
 5 }*s;
 6  
 7     long i;
 8     s=NULL;
 9     t=(struct node *) malloc (sizeof(struct node));
10     for (i=10;i>=1;i--)
11     {
12         //t=(struct node *) malloc (sizeof(struct node));
13         t->value=i;
14         t->next=s;
15         s=t;
16     }
17     while (s)
18     {
19         printf("%ld ",s->value);
20         s=s->next;
21     }

如果没使用t=(struct node *) malloc (sizeof(struct node));当i的初始值大于1，则s,t的大小相同(指向同一个结构体)，且s->next=s，所以一直输出1，进入死循环。

3. 对指针赋值为空后又对指针指向的结构体进行访问或修改

1 struct node
2 {
3     long value;
4     struct node *next;
5 }*s;
6  
7     s=NULL;
8     s->value=1;
9 //    printf("%ld\n",s->value);

4. 释放指针后又对指针进行操作

1 struct node
2 {
3     long value;
4     struct node *next;
5 }*s;
6  
7     free(s);
8 //    s->value=1;
9     printf("%ld\n",s->value);