代码里的result前乱码是什么原因造成的，怎么去掉

daodaohu123

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. char ** str_part(char *str, char *delim)
   
6. {
   
7.         char *s = str;
   
8.         char *d = delim;
   
9.         int n = 0;
   
10. 
    
11.         char **p = (char **)malloc(100 * sizeof(char *));
    
12. 
    
13.         while((p[n] = strtok(s, d)) != NULL){
    
14.                 n++;
    
15.                 s = NULL;
    
16.         }
    
17. 
    
18.         return p;
    
19. }
    
20. 
    
21. int find_cmp(char **str_group, char *string)
    
22. {
    
23.         int ret = 0;
    
24.         int n = 0;
    
25.         int location = -1;
    
26.         char *str = string;
    
27.         int len = strlen(str);
    
28.         char **str_g = str_group;
    
29. 
    
30.         while(str_g[n] != NULL){
    
31.                 ret = strncmp(str_g[n], str, len);
    
32.                 if(ret == 0) location = n;
    
33.                 n++;
    
34.         }
    
35.         return location;
    
36. }
    
37. 
    
38. char **replace_cmp(char **str_group, int num, char *string)
    
39. {
    
40.         char** str_g = str_group;
    
41.         int n = 0;
    
42.         strcpy(str_g[num], string);
    
43. //      strcat(str_g[num], "\0");      
    
44.         return str_g;
    
45. }
    
46. 
    
47. char *rewrite(char **str_group)
    
48. {
    
49.         char **str_g = str_group;
    
50.         int n = 0;
    
51.         int len = 0;
    
52.         char *string = (char *)malloc(100 * sizeof(char));
    
53.         while(str_g[n] != NULL){
    
54.                 len = strlen(str_g[n]);
    
55.                 strncat(string, str_g[n], len);
    
56.                 strcat(string, " ");
    
57.                 n++;
    
58.         }
    
59.         strcat(string, "\n");
    
60. 
    
61.         return string;
    
62. }
    
63. 
    
64. char *extract_str_from_file(char *file, char *keyword)
    
65. {
    
66.         FILE *fp;
    
67.         char *string = (char *)malloc(100 * sizeof(char));
    
68.         char *str = (char *)malloc(100 * sizeof(char));
    
69.         fp = fopen(file, "r");
    
70.         char **p;
    
71.                 while(fgets(string, 1024, fp) != NULL ){
    
72.                         int ret = -1;
    
73.                         strcpy(str, string);
    
74.                         p = str_part(string, " ");
    
75. 
    
76.                         ret = find_cmp(p, keyword);
    
77.                         if(ret >= 0){
    
78.                         printf("content of line is :%s", str);
    
79.                         printf("ret is %d \n", ret);
    
80.                         fclose(fp);
    
81.                         return str;
    
82.                         }
    
83. 
    
84.                 }
    
85.         printf("nothing");
    
86.         return "nothing";
    
87. }
    
88. 
    
89. int newfile_rewrite(char * oldfile, char *newfile, char *cmpcontent, char *repcontent)
    
90. {
    
91.         char str[1024];
    
92.         FILE *fp;
    
93.         FILE *dest;
    
94.         fp = fopen(oldfile, "r");
    
95.         dest = fopen(newfile, "a+");
    
96.         while(!feof(fp))
    
97.         {
    
98.                 if(fgets(str, 1024, fp) != NULL){
    
99.                         if(strcmp(str, cmpcontent)){
    
100.                                 fputs(str, dest);
     
101.                         }
     
102.                         else{
     
103.                                 fputs(repcontent, dest);
     
104.                         }
     
105.                 }
     
106.         }
     
107.         fclose(fp);
     
108.         fclose(dest);
     
109.         return 0;
     
110. }
     
111. 
     
112. int main(int argc, char **argv)
     
113. {
     
114.         int n = 0;
     
115.         int location;
     
116.         char replace_str[]="god";
     
117.         char **str_cmp = (char **)malloc(100 * sizeof(char*));
     
118.         char *string = malloc(100 * sizeof(char));
     
119.         char *delim = " ";
     
120.         char **p;
     
121. 
     
122.         char *dd = (char *)malloc(100 * sizeof(char));
     
123.         string = extract_str_from_file("dd", "me");
     
124.         strcpy(dd, string);
     
125.         p = str_part(string, delim);
     
126. 
     
127.         location = find_cmp(p, "hud");
     
128. 
     
129.         replace_cmp(p, location, replace_str);
     
130.         str_cmp = replace_cmp(p, location, replace_str);
     
131. 
     
132.         char *result = rewrite(str_cmp);
     
133.         printf("result is :%s", result);
     
134.         printf("dd is :%s", dd);
     
135.         newfile_rewrite("dd", "dd_file", dd, result);
     
136.         return 0;
     
137. }
     
138. 
     
139. 
     

复制代码

draytek58

        char **str_g = (char **)malloc(100 * sizeof(char *));
        str_g = str_group;
不小心看到这我就决定放弃了。

bruceteen

代码好长呀，估计很少有人愿意看一遍，要不你直接说说看你想实现什么功能

daodaohu123

回复 3# bruceteen


    result输出时前面有些乱码，影响我将数据导入文件 不知道怎么去掉，或是那里错误造成的

daodaohu123

回复 2# draytek58


    写的不好 能告诉下正确格式或写法怎么写吗 谢谢

daodaohu123

回复 3# bruceteen


    调用rewrite之前数据是正常的

draytek58

回复 5# daodaohu123


    你还没看出那句有问题吗？
malloc 申请了内存，地址存在变量里，然后你又写了变量，memory leak。。
还发现问题不少，比如
        strcpy(str_g[num], string);
        strcat(str_g[num], "\0");
strcpy会拷贝原字符串最后的 '\0' 的，不用后面那句strcat(str_g[num], "\0")。

乱码肯定就是你申请了内存，但是写在了其它地方。读的时候也不知道你读的哪的。
PS. 我没看你代码

帅绝人寰

一贯写臭代码的菜鸟都觉得， 这代码太臭了。。。

daodaohu123

回复 8# 帅绝人寰


    我的代码自己觉得也很烂， 麻烦你告诉下怎么改 谢谢了

daodaohu123

回复 7# draytek58


    我回去 在看看指针这 谢谢你的回答