[已解决]求解

cccc678

学到现在，还是不知道指针有什么用？

最佳答案

月排行榜 / 总排行榜

人造人

2022-11-20 13:40:32

下面是一个list类型的通用容器，这个程序使用了指针
指针没有用吗？如果不用指针的话，要怎么实现这样的程序呢？

1. sh-5.1$ ls
   
2. list.c        list.h        main.c
   
3. sh-5.1$ cat main.c
   
4. #include "list.h"
   
5. #include <stdio.h>
   
6. 
   
7. void output(const list_t *list, size_t index) {
   
8.     if(index >= list_size(list)) return;
   
9.     output(list, index + 1);
   
10.     int temp; list_get(list, index, &temp, sizeof(temp));
    
11.     printf("%d ", temp);
    
12. }
    
13. 
    
14. int main(void) {
    
15.     list_t *list = list_init();
    
16.     for(size_t i = 0; i < 5; ++i) {
    
17.         int temp; scanf("%d", &temp);
    
18.         list_append(list, &temp, sizeof(temp));
    
19.     }
    
20.     output(list, 0); puts("");
    
21.     list_deinit(list);
    
22.     return 0;
    
23. }
    
24. sh-5.1$ cat list.h
    
25. #ifndef _LIST_H_
    
26. #define _LIST_H_
    
27. 
    
28. #include <stddef.h>
    
29. #include <stdbool.h>
    
30. 
    
31. struct list_node_tag {
    
32.     void *data; size_t size;
    
33.     struct list_node_tag *next;
    
34. };
    
35. 
    
36. typedef struct {
    
37.     struct list_node_tag *head;
    
38.     size_t size;
    
39. } list_t;
    
40. 
    
41. list_t *list_init(void);
    
42. void list_deinit(list_t *list);
    
43. bool list_clean(list_t *list);
    
44. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
45. bool list_delete(list_t *list, size_t index);
    
46. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
47. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
48. bool list_append(list_t *list, const void *data, size_t size);
    
49. size_t list_size(const list_t *list);
    
50. bool list_empty(const list_t *list);
    
51. 
    
52. #endif
    
53. sh-5.1$ cat list.c
    
54. #include "list.h"
    
55. #include <stdlib.h>
    
56. #include <memory.h>
    
57. 
    
58. list_t *list_init(void) {
    
59.     list_t *list = malloc(sizeof(*list));
    
60.     if(!list) return NULL;
    
61.     list->head = NULL;
    
62.     list->size = 0;
    
63.     return list;
    
64. }
    
65. 
    
66. void list_deinit(list_t *list) {
    
67.     if(!list) return;
    
68.     list_clean(list);
    
69.     free(list);
    
70. }
    
71. 
    
72. bool list_clean(list_t *list) {
    
73.     if(!list) return false;
    
74.     while(!list_empty(list)) if(!list_delete(list, 0)) return false;
    
75.     return true;
    
76. }
    
77. 
    
78. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
79.     if(!list) return false;
    
80.     if(list_size(list) < index) return false;
    
81.     if(!data) return false;
    
82.     struct list_node_tag **current = &list->head;
    
83.     while(index--) current = &(*current)->next;
    
84.     struct list_node_tag *node = malloc(sizeof(*node));
    
85.     if(!node) return false;
    
86.     node->data = malloc(size);
    
87.     if(!node->data) {free(node); return false;}
    
88.     memcpy(node->data, data, size);
    
89.     node->size = size;
    
90.     node->next = *current;
    
91.     *current = node;
    
92.     ++list->size;
    
93.     return true;
    
94. }
    
95. 
    
96. bool list_delete(list_t *list, size_t index) {
    
97.     if(!list) return false;
    
98.     if(list_size(list) <= index) return false;
    
99.     struct list_node_tag **current = &list->head;
    
100.     while(index--) current = &(*current)->next;
     
101.     struct list_node_tag *temp = *current;
     
102.     *current = temp->next;
     
103.     free(temp->data); free(temp);
     
104.     --list->size;
     
105.     return true;
     
106. }
     
107. 
     
108. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
109.     if(!list) return false;
     
110.     if(list_size(list) <= index) return false;
     
111.     if(!data) return false;
     
112.     struct list_node_tag *const *current = &list->head;
     
113.     while(index--) current = &(*current)->next;
     
114.     struct list_node_tag *temp = *current;
     
115.     if(temp->size > size) return false;
     
116.     memcpy(data, temp->data, temp->size);
     
117.     return true;
     
118. }
     
119. 
     
120. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
121.     bool res = list_delete(list, index);
     
122.     return res ? list_insert(list, index, data, size) : res;
     
123. }
     
124. 
     
125. bool list_append(list_t *list, const void *data, size_t size) {
     
126.     if(!list) return false;
     
127.     return list_insert(list, list_size(list), data, size);
     
128. }
     
129. 
     
130. size_t list_size(const list_t *list) {
     
131.     if(!list) return 0;
     
132.     return list->size;
     
133. }
     
134. 
     
135. bool list_empty(const list_t *list) {
     
136.     if(!list) return true;
     
137.     return list_size(list) == 0;
     
138. }
     
139. sh-5.1$ gcc -g -Wall -o main main.c list.c
     
140. sh-5.1$ ./main
     
141. 1 2 3 4 5
     
142. 5 4 3 2 1
     
143. sh-5.1$
     

复制代码

跳转到最佳答案楼层

jackz007

        那你就认为它没用好了，这有什么好纠结的。

人造人

下面是一个list类型的通用容器，这个程序使用了指针
指针没有用吗？如果不用指针的话，要怎么实现这样的程序呢？

1. sh-5.1$ ls
   
2. list.c        list.h        main.c
   
3. sh-5.1$ cat main.c
   
4. #include "list.h"
   
5. #include <stdio.h>
   
6. 
   
7. void output(const list_t *list, size_t index) {
   
8.     if(index >= list_size(list)) return;
   
9.     output(list, index + 1);
   
10.     int temp; list_get(list, index, &temp, sizeof(temp));
    
11.     printf("%d ", temp);
    
12. }
    
13. 
    
14. int main(void) {
    
15.     list_t *list = list_init();
    
16.     for(size_t i = 0; i < 5; ++i) {
    
17.         int temp; scanf("%d", &temp);
    
18.         list_append(list, &temp, sizeof(temp));
    
19.     }
    
20.     output(list, 0); puts("");
    
21.     list_deinit(list);
    
22.     return 0;
    
23. }
    
24. sh-5.1$ cat list.h
    
25. #ifndef _LIST_H_
    
26. #define _LIST_H_
    
27. 
    
28. #include <stddef.h>
    
29. #include <stdbool.h>
    
30. 
    
31. struct list_node_tag {
    
32.     void *data; size_t size;
    
33.     struct list_node_tag *next;
    
34. };
    
35. 
    
36. typedef struct {
    
37.     struct list_node_tag *head;
    
38.     size_t size;
    
39. } list_t;
    
40. 
    
41. list_t *list_init(void);
    
42. void list_deinit(list_t *list);
    
43. bool list_clean(list_t *list);
    
44. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
45. bool list_delete(list_t *list, size_t index);
    
46. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
47. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
48. bool list_append(list_t *list, const void *data, size_t size);
    
49. size_t list_size(const list_t *list);
    
50. bool list_empty(const list_t *list);
    
51. 
    
52. #endif
    
53. sh-5.1$ cat list.c
    
54. #include "list.h"
    
55. #include <stdlib.h>
    
56. #include <memory.h>
    
57. 
    
58. list_t *list_init(void) {
    
59.     list_t *list = malloc(sizeof(*list));
    
60.     if(!list) return NULL;
    
61.     list->head = NULL;
    
62.     list->size = 0;
    
63.     return list;
    
64. }
    
65. 
    
66. void list_deinit(list_t *list) {
    
67.     if(!list) return;
    
68.     list_clean(list);
    
69.     free(list);
    
70. }
    
71. 
    
72. bool list_clean(list_t *list) {
    
73.     if(!list) return false;
    
74.     while(!list_empty(list)) if(!list_delete(list, 0)) return false;
    
75.     return true;
    
76. }
    
77. 
    
78. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
79.     if(!list) return false;
    
80.     if(list_size(list) < index) return false;
    
81.     if(!data) return false;
    
82.     struct list_node_tag **current = &list->head;
    
83.     while(index--) current = &(*current)->next;
    
84.     struct list_node_tag *node = malloc(sizeof(*node));
    
85.     if(!node) return false;
    
86.     node->data = malloc(size);
    
87.     if(!node->data) {free(node); return false;}
    
88.     memcpy(node->data, data, size);
    
89.     node->size = size;
    
90.     node->next = *current;
    
91.     *current = node;
    
92.     ++list->size;
    
93.     return true;
    
94. }
    
95. 
    
96. bool list_delete(list_t *list, size_t index) {
    
97.     if(!list) return false;
    
98.     if(list_size(list) <= index) return false;
    
99.     struct list_node_tag **current = &list->head;
    
100.     while(index--) current = &(*current)->next;
     
101.     struct list_node_tag *temp = *current;
     
102.     *current = temp->next;
     
103.     free(temp->data); free(temp);
     
104.     --list->size;
     
105.     return true;
     
106. }
     
107. 
     
108. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
109.     if(!list) return false;
     
110.     if(list_size(list) <= index) return false;
     
111.     if(!data) return false;
     
112.     struct list_node_tag *const *current = &list->head;
     
113.     while(index--) current = &(*current)->next;
     
114.     struct list_node_tag *temp = *current;
     
115.     if(temp->size > size) return false;
     
116.     memcpy(data, temp->data, temp->size);
     
117.     return true;
     
118. }
     
119. 
     
120. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
121.     bool res = list_delete(list, index);
     
122.     return res ? list_insert(list, index, data, size) : res;
     
123. }
     
124. 
     
125. bool list_append(list_t *list, const void *data, size_t size) {
     
126.     if(!list) return false;
     
127.     return list_insert(list, list_size(list), data, size);
     
128. }
     
129. 
     
130. size_t list_size(const list_t *list) {
     
131.     if(!list) return 0;
     
132.     return list->size;
     
133. }
     
134. 
     
135. bool list_empty(const list_t *list) {
     
136.     if(!list) return true;
     
137.     return list_size(list) == 0;
     
138. }
     
139. sh-5.1$ gcc -g -Wall -o main main.c list.c
     
140. sh-5.1$ ./main
     
141. 1 2 3 4 5
     
142. 5 4 3 2 1
     
143. sh-5.1$
     

复制代码

竹逸

指针是c的灵魂，指哪打哪，强大的令人发指

xiaosi4081

指针？

指针在一些数据结构里很重要

例如链表

其实不用太纠结于指针的写法，需要用到是百度一下就行了

jackz007

       有一个基本事实是，所有的数组、字符串都是作为指针传递给函数的，如果没有指针，那么，有一件事可以肯定，无法把数组、字符串等内存块性质的数据传递进函数进行处理。

竹逸

xiaosi4081 发表于 2022-11-20 13:56
指针？

指针在一些数据结构里很重要

何止重要，简直就是非常非常非常重要

无论是数据还是地址还是指令代码，都得用到指针，否则cpu就无法寻址。

竹逸

要实现多态，就得用到指针

桃花飞舞

说实话指针在强大和我毛关系，就当它没用好了，纠结什么？

两手空空儿

去看小甲鱼的带你学C，指针那部分可以多刷几遍

jhq999

指针就是内存地址，相当于现实中的地址
可以把内存想象成储物柜，指针就是储存东西后，储物柜的钥匙牌，上面有你储存东西的盒子的编号相当于指针，你可以根据这个编号可以找到那个被存的东西
你也可以把钥匙牌放到其他箱子，放钥匙牌的箱子的钥匙牌就是指针的指针

高山

名称：C++指针详解
链接：https://blog.csdn.net/weixin_39640298/article/details/84900326
（转载在CSDN）

指针是“指向（point to）”另外一种类型的复合类型。复合类型是指基于其它类型定义的类型。

理解指针，先从内存说起：内存是一个很大的，线性的字节数组。每一个字节都是固定的大小，由8个二进制位组成。最关键的是，每一个字节都有一个唯一的编号,编号从0开始，一直到最后一个字节。

程序加载到内存中后，在程序中使用的变量、常量、函数等数据，都有自己唯一的一个编号，这个编号就是这个数据的地址。