c语言怎么实现分隔

fender0107401

__BlueGuy_ 发表于 2014-08-25 13:20
发飙了么？

你就是个“逗逼”。

天天在CU刷存在感的“逗逼”。

cobras

改版，更符合题目的要求。加入提示信息。

1. 
   
2. /* linsplit.c */
   
3. 
   
4. #include <stdio.h>
   
5. #include <string.h>
   
6. #include <stdlib.h>
   
7. 
   
8. #define MAX_LINE      256
   
9. #define FILE_PATH "data/data.txt"
   
10. 
    
11. int nstr_len(const char *s, int lmt)
    
12. {
    
13.         int i;
    
14. 
    
15.         for (i = 0; i < lmt && s[i] != '\0'; ++i) {
    
16.         }
    
17.         return i;
    
18. }
    
19. 
    
20. int read_file_line(FILE *fp, char *buf, int buf_len)
    
21. {
    
22.         int len;
    
23. 
    
24.         while (fgets(buf, buf_len, fp) != NULL) {
    
25.                 len = nstr_len(buf, buf_len);
    
26.                 if (len > 0 && buf[len - 1] == '\n') {
    
27.                         return 0;
    
28.                 }
    
29.                 return -2; /* error: buffer two small */
    
30.         }
    
31.         return -1; /* error: file end */
    
32. }
    
33. 
    
34. int line_splite(const char *file, int *o_tab, int tab_len)
    
35. {
    
36.         char buf[MAX_LINE];
    
37.         char *p, *np;
    
38.         FILE *fp;
    
39.         int data;
    
40.         int i;
    
41.         int retval;
    
42. 
    
43.         fp = fopen(file, "r");
    
44.         if (fp != NULL) {
    
45.                 i = 0;
    
46.                 while ((retval = read_file_line(fp, buf, MAX_LINE)) != -1) {
    
47.                         if (retval == -2) {
    
48.                                 if (o_tab == NULL) {
    
49.                                         puts("error: line too long, skip this line");
    
50.                                 }
    
51.                                 while ((retval = read_file_line(fp, buf, MAX_LINE)) == -2);
    
52.                                 if (retval == -1) {
    
53.                                         break;
    
54.                                 }
    
55.                         }else {
    
56.                                 p = strtok(buf, ",\n");
    
57.                                 if (p != NULL) {
    
58.                                         do {
    
59.                                                 np = p;
    
60.                                                 data = strtol(p, &np, 10);
    
61.                                                 if (p != np) {
    
62.                                                         if (i < tab_len && o_tab != NULL) {
    
63.                                                                 o_tab[i] = data;
    
64.                                                         }
    
65.                                                         ++i;
    
66.                                                 }
    
67.                                         }while ((p = strtok(NULL, ",\n")) != NULL);
    
68.                                 }
    
69.                         }
    
70.                 }
    
71.                 fclose(fp);
    
72.                 return i;
    
73.         }
    
74.         return -1;
    
75. }
    
76. 
    
77. int main(int argc, const char *argv[])
    
78. {
    
79.         const char *file;
    
80.         int *data;
    
81.         int cnt;
    
82.         int i;
    
83. 
    
84.         if (argc > 1) {
    
85.                 file = argv[1];
    
86.         }else {
    
87.                 file = FILE_PATH;
    
88.                 puts("no file, use default.");
    
89.         }
    
90.         printf("open file \"%s\".\n", file);
    
91.         printf("max line buffer: %d\n", MAX_LINE);
    
92.         cnt = line_splite(file, NULL, 0);
    
93.         if (cnt != -1) {
    
94.                 data = (int *)malloc(cnt * sizeof(int));
    
95.                 if (data != NULL) {
    
96.                         line_splite(file, data, cnt);
    
97.                         printf("list all %d number(s):\n", cnt);
    
98.                         for (i = 0; i < cnt; ++i) {
    
99.                                 printf("    %d: %d\n", i, data[i]);
    
100.                         }
     
101.                         free(data);
     
102.                         return 0;
     
103.                 }else {
     
104.                         puts("error: no memory");
     
105.                 }
     
106.         }else {
     
107.                 puts("error: can't open file");
     
108.         }
     
109.         return -1;
     
110. }
     

复制代码

yulihua49

noword2k 发表于 2014-08-25 11:09
题目是，写一个函数，要求输入文件名，解析里面的以逗号分割，不定行数、列数的数字，返回一个数组。
你 ...

你那个C++函数，很好。
给个建议，文件，就不要给文件名了，直接传fp，这样可以用到stdin，这个可是个重要资源哦！
看：static int insert_a_table(T_SQL_Connect *db_conn,FILE *xfd,char *tabname,int param_ver)
当时我们那个xfd就来自stdin，sidin又是由另一个脚本程序解析xml得来的。你看，我也是不反对用脚本程序的。
为了多线程应用，strtok改strtok_r,这样就完美了。
最后，如果你认为这个功能很重要，很通用，就把这个函数加到你的应用工具库，以后，在有需要时，一行语句就解决问题，比python行数少了吧？

前边54楼，我给你的那个数据库泛型的例子，100多行，其实它后边的工具库，上万行。但是这个上万行（大量的字符串处理，正则表达式什么的），不是每次都要写的，在N年前写完了它，以后用的时候，就没有几行语句了。
而且在应用的层面上，概念简单，逻辑清晰。
因此，得不出C/C++不适合处理XX问题的结论，它依然是适合处理的。

代码量的多少，与适合不适合没有关系。
有时，100行的代码，概念清晰，也好写，也好读。10行的代码，逻辑晦涩，照样读不懂。

yulihua49

cobras 发表于 2014-08-25 13:26
改版，更符合题目的要求。加入提示信息。

read_file_line
狗熊掰棒子了，都给读出来了，就返回了最后一行？

cobras

yulihua49 发表于 2014-08-25 16:03
read_file_line
狗熊掰棒子了，都给读出来了，就返回了最后一行？

read_file_line的功能看自己怎么用。我的通常做法是跳过超长的文本行不处理。

cobras

致于线程安全不在考虑范围。因为这只是个例子。

cobras

进一步改进版。有超长行警告。

1. 
   
2. /* linsplit.c */
   
3. 
   
4. #include <stdio.h>
   
5. #include <string.h>
   
6. #include <stdlib.h>
   
7. 
   
8. #define MAX_LINE      256
   
9. #define FILE_PATH "data/data.txt"
   
10. 
    
11. int read_file_line(FILE *fp, char *buf, int buf_len)
    
12. {
    
13.         int len;
    
14. 
    
15.         while (fgets(buf, buf_len, fp) != NULL) {
    
16.                 len = strlen(buf);
    
17.                 if (len > 0 && buf[len - 1] == '\n' || feof(fp)) {
    
18.                         return 0;
    
19.                 }
    
20.                 return -2; /* error: buffer two small */
    
21.         }
    
22.         return -1; /* error: file end */
    
23. }
    
24. 
    
25. int line_splite(const char *file, int *o_tab, int tab_len, int *o_count)
    
26. {
    
27.         char buf[MAX_LINE];
    
28.         char *p, *np;
    
29.         FILE *fp;
    
30.         int data;
    
31.         int i;
    
32.         int retval;
    
33.         int overflow;
    
34. 
    
35.         fp = fopen(file, "r");
    
36.         if (fp != NULL) {
    
37.                 i = 0;
    
38.                 overflow = 0;
    
39.                 while ((retval = read_file_line(fp, buf, MAX_LINE)) != -1) {
    
40.                         if (retval == -2) {
    
41.                                 ++overflow;
    
42.                                 while ((retval = read_file_line(fp, buf, MAX_LINE)) == -2) {
    
43.                                 }
    
44.                         }else {
    
45.                                 if ((p = strtok(buf, ",\n")) != NULL) {
    
46.                                         do {
    
47.                                                 np = p;
    
48.                                                 data = strtol(p, &np, 10);
    
49.                                                 if (p != np) {
    
50.                                                         if (i < tab_len && o_tab != NULL) {
    
51.                                                                 o_tab[i] = data;
    
52.                                                         }
    
53.                                                         ++i;
    
54.                                                 }
    
55.                                         }while ((p = strtok(NULL, ",\n")) != NULL);
    
56.                                 }
    
57.                         }
    
58.                 }
    
59.                 fclose(fp);
    
60.                 if (o_count != NULL) {
    
61.                         *o_count = i;
    
62.                 }
    
63.                 return overflow;
    
64.         }
    
65.         return -1; /* error: file not found */
    
66. }
    
67. 
    
68. int main(int argc, const char *argv[])
    
69. {
    
70.         const char *file;
    
71.         int *data;
    
72.         int cnt;
    
73.         int i;
    
74.         int retval;
    
75. 
    
76.         if (argc > 1) {
    
77.                 file = argv[1];
    
78.         }else {
    
79.                 file = FILE_PATH;
    
80.                 puts("not specify, use default file.");
    
81.         }
    
82.         printf("open file \"%s\" (max line: %d).\n", file, MAX_LINE - 1);
    
83.         if ((retval = line_splite(file, NULL, 0, &cnt)) != -1) {
    
84.                 if (retval) {
    
85.                         printf("warning: skip exceed %d line(s)\n", retval);
    
86.                 }
    
87.                 if ((data = (int *)malloc(cnt * sizeof(int))) != NULL) {
    
88.                         line_splite(file, data, cnt, NULL);
    
89.                         printf("get %d number(s). list all:\n", cnt);
    
90.                         for (i = 0; i < cnt; ++i) {
    
91.                                 printf("  %d: %d\n", i, data[i]);
    
92.                         }
    
93.                         free(data);
    
94.                         return 0;
    
95.                 }else {
    
96.                         puts("error: no memory");
    
97.                 }
    
98.         }else {
    
99.                 puts("error: can't open file");
    
100.         }
     
101.         return -1;
     
102. }
     

复制代码

Fixend

大家都很无聊啊。