[已解决]想请教各位大佬关于结构体指针的问题

cookies945

1. struct students{
   
2.         char name[10];
   
3.         int num;
   
4.         float score;
   
5.         struct students *next;       
   
6. };

复制代码

这么一个结构体，我声明一个指针struct students *S!
请问
*S1->next = NULL
S1 = NULL
S1 = NULL
分别是什么意思，请大佬们讲的详细一些

最佳答案

月排行榜 / 总排行榜

jackz007

2019-3-24 12:22:59

      首先应该明白，s 和 s -> next 是同种类型的变量，都是 struct students * 类型，也就是说，他们都是指针类型，在变量定义和初始化的时候，s = NULL 和 s -> next = NULL 意思是，把这 2 个指针初始化为空值，这就意味着，这 2 个指针此刻并没有指向任何一个内存区域，所以，还不能作为结构体用来承载信息和被访问。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. struct students{
   
6.         char name[10]          ;
   
7.         int num                ;
   
8.         float score            ;
   
9.         struct students * next ;  // 链表节点指针，用于指向下一个节点      
   
10. }                              ;
    
11. 
    
12. main(void)
    
13. {
    
14.         struct students * s1 , * s2                                 ; // 声明 s1、s2 为链表节点指针
    
15.         s1 = (struct students *) malloc(sizeof(struct students *))  ; // 通过 malloc() 分配一块内存，创建第一个链表节点，用指针 s1 指向这个节点
    
16.         strcpy(s1 -> name , "张三")                                 ; // 为节点 s1 成员赋值
    
17.         s1 -> num   = 102                                           ; // 为节点 s1 成员赋值
    
18.         s1 -> score = 88.5                                          ; // 为节点 s1 成员赋值
    
19.         s1 -> next = NULL                                           ; // 为节点 s1 成员赋值
    
20.         s2 = (struct students *) malloc(sizeof(struct students *))  ; // 通过 malloc() 分配一块内存，创建第二个链表节点，用指针 s2 指向这个节点
    
21.         strcpy(s2 -> name , "李四")                                 ; // 为节点 s2 成员赋值
    
22.         s2 -> num   = 103                                           ; // 为节点 s2 成员赋值
    
23.         s2 -> score = 82.9                                          ; // 为节点 s2 成员赋值
    
24.         s2 -> next = NULL                                           ; // 为节点 s2 成员赋值
    
25. 
    
26.         s1 -> next = s2                                             ; // 让第节点 s1 的链表指针指向 s2，这样，s1 -> next == s2
    
27.         s2 -> next = s1                                             ; // 让第节点 s2 的链表指针指向 s1，这样，s2 -> next == s1
    
28.                                                                       // 这样，s1 与 s2 形成一个闭环，s1 -> next 指向 s2，而 s1 -> next -> next 又指回了自己
    
29.         printf("s1 -> name  : %s\n" , s1 -> name)                   ; // 利用 s1 向屏幕输出：s1 -> name  : 张三
    
30.         printf("s1 -> num   : %d\n" , s1 -> num)                    ; // 利用 s1 向屏幕输出：s1 -> num   : 102
    
31.         printf("s1 -> score : %4.1f\n , s1 -> score)                ; // 利用 s1 向屏幕输出：s1 -> score : 88.5
    
32. 
    
33.         printf("s1 -> name  : %s\n" , s2 -> next -> name)           ; // 利用 s2 向屏幕输出：s1 -> name  : 张三
    
34.         printf("s1 -> num   : %d\n" , s2 -> next -> num)            ; // 利用 s2 向屏幕输出：s1 -> num   : 102
    
35.         printf("s1 -> score : %4.1f\n , s2 -> next -> score)        ; // 利用 s2 向屏幕输出：s1 -> score : 88.5
    
36. 
    
37.         free(s1)                                                    ; // 使用完毕释放节点内存
    
38.         free(s2)                                                    ; // 使用完毕释放节点内存
    
39. }
    

复制代码

跳转到最佳答案楼层

jackz007

      首先应该明白，s 和 s -> next 是同种类型的变量，都是 struct students * 类型，也就是说，他们都是指针类型，在变量定义和初始化的时候，s = NULL 和 s -> next = NULL 意思是，把这 2 个指针初始化为空值，这就意味着，这 2 个指针此刻并没有指向任何一个内存区域，所以，还不能作为结构体用来承载信息和被访问。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. struct students{
   
6.         char name[10]          ;
   
7.         int num                ;
   
8.         float score            ;
   
9.         struct students * next ;  // 链表节点指针，用于指向下一个节点      
   
10. }                              ;
    
11. 
    
12. main(void)
    
13. {
    
14.         struct students * s1 , * s2                                 ; // 声明 s1、s2 为链表节点指针
    
15.         s1 = (struct students *) malloc(sizeof(struct students *))  ; // 通过 malloc() 分配一块内存，创建第一个链表节点，用指针 s1 指向这个节点
    
16.         strcpy(s1 -> name , "张三")                                 ; // 为节点 s1 成员赋值
    
17.         s1 -> num   = 102                                           ; // 为节点 s1 成员赋值
    
18.         s1 -> score = 88.5                                          ; // 为节点 s1 成员赋值
    
19.         s1 -> next = NULL                                           ; // 为节点 s1 成员赋值
    
20.         s2 = (struct students *) malloc(sizeof(struct students *))  ; // 通过 malloc() 分配一块内存，创建第二个链表节点，用指针 s2 指向这个节点
    
21.         strcpy(s2 -> name , "李四")                                 ; // 为节点 s2 成员赋值
    
22.         s2 -> num   = 103                                           ; // 为节点 s2 成员赋值
    
23.         s2 -> score = 82.9                                          ; // 为节点 s2 成员赋值
    
24.         s2 -> next = NULL                                           ; // 为节点 s2 成员赋值
    
25. 
    
26.         s1 -> next = s2                                             ; // 让第节点 s1 的链表指针指向 s2，这样，s1 -> next == s2
    
27.         s2 -> next = s1                                             ; // 让第节点 s2 的链表指针指向 s1，这样，s2 -> next == s1
    
28.                                                                       // 这样，s1 与 s2 形成一个闭环，s1 -> next 指向 s2，而 s1 -> next -> next 又指回了自己
    
29.         printf("s1 -> name  : %s\n" , s1 -> name)                   ; // 利用 s1 向屏幕输出：s1 -> name  : 张三
    
30.         printf("s1 -> num   : %d\n" , s1 -> num)                    ; // 利用 s1 向屏幕输出：s1 -> num   : 102
    
31.         printf("s1 -> score : %4.1f\n , s1 -> score)                ; // 利用 s1 向屏幕输出：s1 -> score : 88.5
    
32. 
    
33.         printf("s1 -> name  : %s\n" , s2 -> next -> name)           ; // 利用 s2 向屏幕输出：s1 -> name  : 张三
    
34.         printf("s1 -> num   : %d\n" , s2 -> next -> num)            ; // 利用 s2 向屏幕输出：s1 -> num   : 102
    
35.         printf("s1 -> score : %4.1f\n , s2 -> next -> score)        ; // 利用 s2 向屏幕输出：s1 -> score : 88.5
    
36. 
    
37.         free(s1)                                                    ; // 使用完毕释放节点内存
    
38.         free(s2)                                                    ; // 使用完毕释放节点内存
    
39. }
    

复制代码

cookies945

jackz007 发表于 2019-3-24 12:22
首先应该明白，s 和 s -> next 是同种类型的变量，都是 struct students * 类型，也就是说，他们都是 ...

s = NULL 和 s -> next = NULL 意思是，把这 2 个指针初始化为空值，这就意味着，这 2 个指针此刻并没有指向任何一个内存区域，所以，还不能作为结构体用来承载信息和被访问。
这个是还没有分配内存时把指针指向空才不能作为结构体凯承载信息是么？还有就是指向空值时不能被访问的么？
还有一个问题是 只是声明struct students *s （*s）的含义是什么？是这个结构体么？我记得时可(*s).next的。

jackz007

      你的理解完全正确！

1.         struct students stu , * ps ;
   
2.         ps = & stu                 ; // 把 ps 指向 stu
   
3.         (* ps) . name              ; // stu . name
   
4.         (* ps) . num               ; // stu . num
   
5.         (* ps) . score             ; // stu . score
   
6.         ps -> name                 ; // stu . name
   
7.         ps -> num                  ; // stu . num
   
8.         ps -> score                ; // stu . score

复制代码

cookies945

jackz007 发表于 2019-3-24 12:22
首先应该明白，s 和 s -> next 是同种类型的变量，都是 struct students * 类型，也就是说，他们都是 ...

哦对了，还有一件事情就是**S1 应该怎么理解？
是 **S1 是一个结构体，还是和我想得不一样？

jackz007

cookies945 发表于 2019-3-24 14:57
哦对了，还有一件事情就是**S1 应该怎么理解？
是 **S1 是一个结构体，还是和我想得不一样？

    ** s 是指向节点的指针的指针，意思是 s 所指向的内存中可以保存一个指向节点的指针，而这个指针 (* s) 可以指向一个节点。

1.   struct students stu , ** s ;
   
2.   * s = & stu                    ;
   
3.   (** s) . name                ;
   
4.   (** s) . num                  ;
   
5.   (** s) . score                 ;
   
6.   (* s) -> name                ;
   
7.   (* s) -> num                 ;
   
8.   (* s) -> score                ;

复制代码

cookies945

jackz007 发表于 2019-3-24 15:00
struct students stu , ** s ;
  * s = & stu                    ;
  (** s) . name                ...

哦好的谢谢大佬

煎蛋aa

看看这些又学到了不少啊