C 对文件内容操作

genious588

大家好：
       我想对一个文件a操作，a的内容是:
                     a=1,b=2
                     c=3
                     d=4
         1.  现在想把c 的值打印出来，也就是3，请问怎么弄？
      2.  把c 的值变成10，既a的内容是：
              a=1,b=2
                     c=10
                     d=4
             怎么弄？
不用shell，请大家指点一下！谢谢

genious588

忘了补充了，尽量能做到通用性，因为a文件里可能还会有关其他的带a字符

alexhappy

APUE 第3章和第5章，看完了你就会了

zhuhefang2006

用open，read，write这些文件操作系统调用

net_robber

Shell是最偷懒的方式

选择C就只能自己动手

genious588

没有人能给在下举个例子，抛砖引玉一下吗？

cobras

1. 
   
2. #include <ctype.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. 
   
7. struct s_exp {
   
8.         struct s_exp *previous, *next;
   
9.         char *name;
   
10.         long value;
    
11. };
    
12. 
    
13. int get_char(FILE *fp, long offset)
    
14. {
    
15.         char c;
    
16. 
    
17.         if (fseek(fp, offset, SEEK_SET) == 0) {
    
18.                 if (fread(&c, 1, 1, fp) == 1) {
    
19.                         return c;
    
20.                 }
    
21.         }
    
22.         return EOF;
    
23. }
    
24. 
    
25. int get_name_length(FILE *fp, long offset)
    
26. {
    
27.         int n;
    
28.         int c;
    
29. 
    
30.         for (n = 0; (c = get_char(fp, offset)) != EOF; n++) {
    
31.                 if (c == '=') {
    
32.                         break;
    
33.                 }
    
34.                 offset++;
    
35.         }
    
36.         return n;
    
37. }
    
38. 
    
39. void trim_right(char *s)
    
40. {
    
41.         int len;
    
42. 
    
43.         for (len = strlen(s) - 1; len >= 0; len--) {
    
44.                 if (!isspace(s[len])) {
    
45.                         s[len + 1] = '\0';
    
46.                         break;
    
47.                 }
    
48.         }
    
49. }
    
50. 
    
51. int get_name(FILE *fp, long *offset, char *buff, int len)
    
52. {
    
53.         long i;
    
54.         int n;
    
55.         int c;
    
56. 
    
57.         i = *offset;
    
58.         for (n = 0; (c = get_char(fp, i)) != EOF && n < len; n++) {
    
59.                 if (c == '=') {
    
60.                         buff[n] = '\0';
    
61.                         trim_right(buff);
    
62.                         break;
    
63.                 }
    
64.                 buff[n] = c;
    
65.                 i++;
    
66.         }
    
67.         *offset = i;
    
68.         return 0;
    
69. }
    
70. 
    
71. int get_text(FILE *fp, long *offset, const char *text)
    
72. {
    
73.         long i;
    
74.         int c;
    
75. 
    
76.         i = *offset;
    
77.         while (*text != '\0') {
    
78.                 c = get_char(fp, i);
    
79.                 if (c != EOF) {
    
80.                         if (c == *text) {
    
81.                                 text++;
    
82.                                 i++;
    
83.                                 continue;
    
84.                         }
    
85.                 }
    
86.                 return -1;
    
87.         }
    
88.         *offset = i;
    
89.         return 0;
    
90. }
    
91. 
    
92. int get_space(FILE *fp, long *offset)
    
93. {
    
94.         int i;
    
95.         int c;
    
96. 
    
97.         i = *offset;
    
98.         c = get_char(fp, i);
    
99.         if (c != EOF) {
    
100.                 if (c == ' ' || c == '\t') {
     
101.                         while ((c = get_char(fp, ++i)) != EOF && c == ' ' || c == '\t') {
     
102.                         }
     
103.                         *offset = i;
     
104.                 }
     
105.                 return 0;
     
106.         }
     
107.         return -1;
     
108. }
     
109. 
     
110. int get_return(FILE *fp, long *offset)
     
111. {
     
112.         if (get_text(fp, offset, "\r\n") == 0) {
     
113.                 return 0;
     
114.         }
     
115.         return -1;
     
116. }
     
117. 
     
118. int get_long(FILE *fp, long *offset, long *value)
     
119. {
     
120.         long i;
     
121.         long val;
     
122.         int c;
     
123. 
     
124.         i = *offset;
     
125.         c = get_char(fp, i);
     
126.         if (c != EOF) {
     
127.                 if (isdigit(c)) {
     
128.                         val = c - '0';
     
129.                         while ((c = get_char(fp, ++i)) != EOF && isdigit(c)) {
     
130.                                 val = val * 10 + c - '0';
     
131.                         }
     
132.                         *value = val;
     
133.                         *offset = i;
     
134.                 }
     
135.                 return 0;
     
136.         }
     
137.         return -1;
     
138. }
     
139. 
     
140. struct s_exp *search_exp(struct s_exp **list, const char *name)
     
141. {
     
142.         struct s_exp *node;
     
143. 
     
144.         if (*list != NULL) {
     
145.                 node = *list;
     
146.                 do {
     
147.                         if (strcmp(node->name, name) == 0) {
     
148.                                 return node;
     
149.                         }
     
150.                         node = node->next;
     
151.                 }while (node != *list);
     
152.         }
     
153.         return NULL;
     
154. }
     
155. 
     
156. struct s_exp *get_exp(FILE *fp, long *offset)
     
157. {
     
158.         long i;
     
159.         struct s_exp exp, *pexp;
     
160.         int len;
     
161. 
     
162.         i = *offset;
     
163.         if (get_space(fp, &i) == 0) {
     
164.                 len = get_name_length(fp, i);
     
165.                 if (len > 0) {
     
166.                         memset(&exp, 0, sizeof(exp));
     
167.                         exp.name = (char *)malloc(len + 1);
     
168.                         if (exp.name != NULL) {
     
169.                                 if (get_name(fp, &i, exp.name, len + 1) == 0) {
     
170.                                         if (get_text(fp, &i, "=") == 0) {
     
171.                                                 if (get_space(fp, &i) == 0) {
     
172.                                                         if (get_long(fp, &i, &exp.value) == 0) {
     
173.                                                                 if (get_space(fp, &i) == 0) {
     
174.                                                                         if (get_text(fp, &i, ",") == 0
     
175.                                                                                 || get_return(fp, &i) == 0) {
     
176.                                                                                 pexp = (struct s_exp *)malloc(sizeof(*pexp));
     
177.                                                                                 if (pexp != NULL) {
     
178.                                                                                         *pexp = exp;
     
179.                                                                                         *offset = i;
     
180.                                                                                         return pexp;
     
181.                                                                                 }
     
182.                                                                         }
     
183.                                                                 }
     
184.                                                         }
     
185.                                                 }
     
186.                                         }
     
187.                                 }
     
188.                                 free(exp.name);
     
189.                         }
     
190.                 }
     
191.         }
     
192.         return NULL;
     
193. }
     
194. 
     
195. int insert_exp(struct s_exp **list, struct s_exp *node)
     
196. {
     
197.         if (search_exp(list, node->name) == NULL) {
     
198.                 if (*list == NULL) {
     
199.                         node->previous = node;
     
200.                         node->next = node;
     
201.                         *list = node;
     
202.                 }else {
     
203.                         node->previous = (*list)->previous;
     
204.                         node->next = *list;
     
205.                         (*list)->previous->next = node;
     
206.                         (*list)->previous = node;
     
207.                 }
     
208.                 return 0;
     
209.         }else {
     
210.                 free(node->name);
     
211.                 free(node);
     
212.                 return 0;
     
213.         }
     
214. }
     
215. 
     
216. int update_exp_value(struct s_exp **list, const char *name, long value)
     
217. {
     
218.         struct s_exp *node;
     
219. 
     
220.         node = search_exp(list, name);
     
221.         if (node != NULL) {
     
222.                 node->value = value;
     
223.                 return 0;
     
224.         }
     
225.         return -1;
     
226. }
     
227. 
     
228. int free_all_exp(struct s_exp **list)
     
229. {
     
230.         struct s_exp *node, *n2;
     
231. 
     
232.         if (*list != NULL) {
     
233.                 node = *list;
     
234.                 do {
     
235.                         n2 = node;
     
236.                         node = node->next;
     
237.                         free(n2->name);
     
238.                         free(n2);
     
239.                 }while (node != *list);
     
240.                 *list = NULL;
     
241.                 return 0;
     
242.         }
     
243.         return -1;
     
244. }
     
245. 
     
246. int write_exp_to_file(struct s_exp **list, const char *fname)
     
247. {
     
248.         struct s_exp *node;
     
249.         FILE *fp;
     
250. 
     
251.         if (*list != NULL) {
     
252.                 fp = fopen(fname, "w");
     
253.                 if (fp != NULL) {
     
254.                         node = *list;
     
255.                         do {
     
256.                                 fprintf(fp, "%s=%lu\n", node->name, node->value);
     
257.                                 node = node->next;
     
258.                         }while (node != *list);
     
259.                         fclose(fp);
     
260.                         return 0;
     
261.                 }
     
262.         }
     
263.         return -1;
     
264. }
     
265. 
     
266. int read_exp_from_file(struct s_exp **list, const char *fname)
     
267. {
     
268.         struct s_exp *node;
     
269.         FILE *fp;
     
270.         long offset;
     
271. 
     
272.         fp = fopen(fname, "rb");
     
273.         if (fp != NULL) {
     
274.                 *list = NULL;
     
275.                 offset = 0;
     
276.                 while ((node = get_exp(fp, &offset)) != NULL) {
     
277.                         insert_exp(list, node);
     
278.                 }
     
279.                 fclose(fp);
     
280.                 return 0;
     
281.         }
     
282.         return -1;
     
283. }
     
284. 
     
285. int main(void)
     
286. {
     
287.         struct s_exp *list;
     
288. 
     
289.         if (read_exp_from_file(&list, "a.txt") == 0) {
     
290.                 update_exp_value(&list, "c", 10);
     
291.                 write_exp_to_file(&list, "con");
     
292.                 free_all_exp(&list);
     
293.                 return 0;
     
294.         }
     
295.         return -1;
     
296. }
     

复制代码