[已解决]为什么我的replacestr函数错误？？

愿你

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #define MAXSIZE 60
   
5. typedef struct{
   
6.         char *ch;
   
7.         int length;
   
8. }HString;
   
9. 
   
10. void initstr(HString *T) //初始化，产生空串。
    
11. {
    
12.         T->ch=(char*)malloc(sizeof(char)*MAXSIZE);
    
13.         if(!(T->ch))
    
14.                 printf("对不起，初始化失败。\n");
    
15.         else
    
16.         {
    
17.                 T->length=0;
    
18.                 printf("恭喜你，初始化成功。\n");
    
19.         }
    
20. 
    
21. }
    
22. 
    
23. void creatstr(HString *T) //初始化开辟空间。
    
24. {
    
25.         char s[MAXSIZE];
    
26.         int len,i;
    
27.         printf("请输入您想要的字符串：");
    
28.         gets(s);
    
29.         len=strlen(s);
    
30. 
    
31.         for(i=0;i<len;i++)
    
32.         {
    
33.                 T->ch[i]=s[i];
    
34.         }
    
35.         T->ch[i]='\0';
    
36.         T->length=len;
    
37.         printf("字符串赋值成功！\n");
    
38. }
    
39. 
    
40. void printstr(HString *T)
    
41. {
    
42.         printf("%s\n",T->ch);
    
43.         printf("打印成功！\n");
    
44. }
    
45. 
    
46. void concatstr(HString *T1,HString *T2) //字符串连接
    
47. {
    
48.         int lengthstr(HString *T);
    
49.         int i,j,len1,len2;
    
50.         len1=lengthstr(T1);
    
51.         len2=lengthstr(T2);
    
52.         for(i=len1,j=0;i<=len1+len2;i++)
    
53.         {
    
54.                 T1->ch[i]=T2->ch[j];
    
55.                 j++;
    
56.         }
    
57.         T1->length=len1+len2;
    
58. }
    
59. int lengthstr(HString *T)   //求字符串的长度
    
60. {
    
61.         int len,i;
    
62.         len=0;
    
63.         i=0;
    
64.         while(T->ch[i]!='\0')
    
65.         {
    
66.                 len++;
    
67.                 i++;
    
68.         }
    
69.         printf("您的字符串长度为：%d\n",len);
    
70.         return len;
    
71. }
    
72. 
    
73. void deletesubstr(HString *T,int pos,int len) //删除从pos位置起的len个字符 注意应加上判断删除位置等是否正确，此处省略，有时间请补上。
    
74. {
    
75.         int i;
    
76.         for(i=pos+len-1;i<T->length;i++)
    
77.         {
    
78.                 T->ch[i-2]=T->ch[i];
    
79.         }
    
80.         T->length=T->length-len;
    
81.         T->ch[T->length]='\0';
    
82. }
    
83. 
    
84. void insertsubstr(HString *T,int pos,HString S) //在pos位置之前插入一个字符串S；
    
85. {
    
86. 
    
87.         int i,len,j;
    
88.         len=S.length;
    
89.         for(i=T->length-1;i>=pos-1;i--) //该循环用以使pos字符（包含pos字符）之后的每一个字符后移，为子串腾出位置。
    
90.         {
    
91.                 T->ch[i+len]=T->ch[i];
    
92.         }
    
93.         T->length=T->length+len;
    
94.         T->ch[T->length]='\0';
    
95.         i=pos-1;
    
96.         for(i,j=0;j<len;j++,i++) //该循环用以将腾出的位置插入子串
    
97.         {
    
98.                 T->ch[i]=S.ch[j];
    
99.         }
    
100. }
     
101. int Indexstr(HString *T,int pos,HString S)//从第pos个字符开始寻找子串S，若找到，则返回其位置。
     
102. {
     
103.         int i,j;
     
104.         i=pos-1;
     
105.         j=0;
     
106.         while(i<=T->length-1&&j<=S.length-1)
     
107.         {
     
108.                 if(T->ch[i]==S.ch[j])
     
109.                 {
     
110.                         ++i;
     
111.                         ++j;
     
112.                 }
     
113.                 else
     
114.                 {
     
115.                         i=i-j+1;
     
116.                         j=0;
     
117.                 }
     
118.         }
     
119.         if(j>=S.length)
     
120.         {
     
121.                 printf("您所需要查询的子串在第%d个位置\n",i-S.length+1);
     
122.                 return i-S.length+1;
     
123.         }
     
124.         else
     
125.         {
     
126.                 printf("尚未查询到您需要的子串\n");
     
127.                 return 0;
     
128.         }
     
129. }
     
130. void replacestr(HString *T,HString T1,HString T2)//将字符串T中等于T1的子串替换成为T2
     
131. {
     
132.         int Indexstr(HString *,int ,HString );
     
133.         void insertsubstr(HString *,int ,HString );
     
134.         void deletesubstr(HString *,int ,int );
     
135.         int pos;
     
136.         pos=0;
     
137.         pos=Indexstr(T,1,T1);
     
138.         while(pos)
     
139.         {
     
140.                 deletesubstr(T,pos ,T1.length );
     
141.                 insertsubstr(T,pos ,T2);
     
142.                 pos=Indexstr(T,pos,T1);
     
143.         }
     
144.         printf("替换完毕.\n");
     
145. }
     
146. 
     
147. 
     
148. 
     
149. 
     
150. 
     
151. 
     
152. int main()
     
153. {
     
154.         HString T1,T2,T3;
     
155.         char str[]="hsy";
     
156.         char str2[]="cute";
     
157.         initstr(&T1);
     
158.         creatstr(&T1);
     
159.         T2.ch=str;
     
160.         T3.ch=str2;
     
161.         T2.length=strlen(T2.ch);//T2.length=lengthstr(&T2);
     
162.         T3.length=strlen(T3.ch);
     
163.         //initstr(&T2);
     
164.         //creatstr(&T2);
     
165.         //printstr(&T);
     
166.         //concatstr(&T1,&T2);
     
167.         //lengthstr(&T1);
     
168.         //printstr(&T1);
     
169.         //deletesubstr(&T1,4,2);
     
170.         //insertsubstr(&T1,3,T2);
     
171.         //printstr(&T1);
     
172.         //Indexstr(&T1,1,T2);
     
173.         printstr(&T1);
     
174.         replacestr(&T1,T2,T3);
     
175.         printstr(&T1);
     
176.         return 0;
     
177. }

复制代码

@人造人

最佳答案

月排行榜 / 总排行榜

人造人

2018-4-21 03:43:31

很明显，deletesubstr函数不是预期的那样工作

跳转到最佳答案楼层

人造人

很明显，deletesubstr函数不是预期的那样工作

人造人

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #define MAXSIZE 60
   
5. typedef struct
   
6. {
   
7.         char *ch;
   
8.         int length;
   
9. } HString;
   
10. 
    
11. void initstr(HString *T) //初始化，产生空串。
    
12. {
    
13.         //T->ch = (char*)malloc(sizeof(char)*MAXSIZE);        // 听某本书上说，永远都不用写sizeof(char)，sizeof(char)恒为1
    
14.         T->ch = malloc(MAXSIZE);
    
15.         if(!(T->ch))
    
16.                 printf("对不起，初始化失败。\n");
    
17.         else
    
18.         {
    
19.                 T->length = 0;
    
20.                 printf("恭喜你，初始化成功。\n");
    
21.         }
    
22. 
    
23. }
    
24. 
    
25. void creatstr(HString *T) //初始化开辟空间。
    
26. {
    
27.         //char s[MAXSIZE];
    
28.         //int len, i;
    
29.         printf("请输入您想要的字符串：");
    
30.         //gets(s);
    
31.         //len = strlen(s);
    
32. 
    
33.         //for(i = 0; i<len; i++)
    
34.         //{
    
35.         //        T->ch[i] = s[i];
    
36.         //}
    
37.         //T->ch[i] = '\0';
    
38.         //T->length = len;
    
39. 
    
40. 
    
41. 
    
42.         // 为什么要用gets，把字符串get到s，然后再复制到T->ch ?  ^_^
    
43.         fgets(T->ch, MAXSIZE, stdin);
    
44.         T->length = strlen(T->ch) - 1;        // '\n'
    
45.         T->ch[T->length] = '\0';
    
46. 
    
47. 
    
48. 
    
49.         printf("字符串赋值成功！\n");
    
50. }
    
51. 
    
52. void printstr(HString *T)
    
53. {
    
54.         printf("%s\n", T->ch);
    
55.         printf("打印成功！\n");
    
56. }
    
57. 
    
58. void concatstr(HString *T1, HString *T2) //字符串连接
    
59. {
    
60.         int lengthstr(HString *T);
    
61.         int i, j, len1, len2;
    
62.         len1 = lengthstr(T1);
    
63.         len2 = lengthstr(T2);
    
64.         for(i = len1, j = 0; i <= len1 + len2; i++)
    
65.         {
    
66.                 T1->ch[i] = T2->ch[j];
    
67.                 j++;
    
68.         }
    
69.         T1->length = len1 + len2;
    
70. }
    
71. int lengthstr(HString *T)   //求字符串的长度
    
72. {
    
73.         int len, i;
    
74.         len = 0;
    
75.         i = 0;
    
76.         while(T->ch[i] != '\0')
    
77.         {
    
78.                 len++;
    
79.                 i++;
    
80.         }
    
81.         printf("您的字符串长度为：%d\n", len);
    
82.         return len;
    
83. }
    
84. 
    
85. void deletesubstr(HString *T, int pos, int len) //删除从pos位置起的len个字符 注意应加上判断删除位置等是否正确，此处省略，有时间请补上。
    
86. {
    
87.         int i;
    
88.         for(i = pos + len - 1; i < T->length; i++)
    
89.         {
    
90.                 T->ch[i - len] = T->ch[i];
    
91.         }
    
92.         T->length = T->length - len;
    
93.         T->ch[T->length] = '\0';
    
94. }
    
95. 
    
96. void insertsubstr(HString *T, int pos, HString S) //在pos位置之前插入一个字符串S；
    
97. {
    
98. 
    
99.         int i, len, j;
    
100.         len = S.length;
     
101.         for(i = T->length - 1; i >= pos - 1; i--) //该循环用以使pos字符（包含pos字符）之后的每一个字符后移，为子串腾出位置。
     
102.         {
     
103.                 T->ch[i + len] = T->ch[i];
     
104.         }
     
105.         T->length = T->length + len;
     
106.         T->ch[T->length] = '\0';
     
107.         i = pos - 1;
     
108.         for(i, j = 0; j<len; j++, i++) //该循环用以将腾出的位置插入子串
     
109.         {
     
110.                 T->ch[i] = S.ch[j];
     
111.         }
     
112. }
     
113. int Indexstr(HString *T, int pos, HString S)//从第pos个字符开始寻找子串S，若找到，则返回其位置。
     
114. {
     
115.         int i, j;
     
116.         i = pos - 1;
     
117.         j = 0;
     
118.         while(i <= T->length - 1 && j <= S.length - 1)
     
119.         {
     
120.                 if(T->ch[i] == S.ch[j])
     
121.                 {
     
122.                         ++i;
     
123.                         ++j;
     
124.                 }
     
125.                 else
     
126.                 {
     
127.                         i = i - j + 1;
     
128.                         j = 0;
     
129.                 }
     
130.         }
     
131.         if(j >= S.length)
     
132.         {
     
133.                 printf("您所需要查询的子串在第%d个位置\n", i - S.length + 1);
     
134.                 return i - S.length + 1;
     
135.         }
     
136.         else
     
137.         {
     
138.                 printf("尚未查询到您需要的子串\n");
     
139.                 return 0;
     
140.         }
     
141. }
     
142. void replacestr(HString *T, HString T1, HString T2)//将字符串T中等于T1的子串替换成为T2
     
143. {
     
144.         int Indexstr(HString *, int, HString);
     
145.         void insertsubstr(HString *, int, HString);
     
146.         void deletesubstr(HString *, int, int);
     
147.         int pos;
     
148.         pos = 0;
     
149.         pos = Indexstr(T, 1, T1);
     
150.         while(pos)
     
151.         {
     
152.                 deletesubstr(T, pos, T1.length);
     
153.                 insertsubstr(T, pos, T2);
     
154.                 pos = Indexstr(T, pos, T1);
     
155.         }
     
156.         printf("替换完毕.\n");
     
157. }
     
158. 
     
159. int main()
     
160. {
     
161.         HString T1, T2, T3;
     
162.         char str[] = "hsy";
     
163.         char str2[] = "cute";
     
164.         initstr(&T1);
     
165.         creatstr(&T1);
     
166.         T2.ch = str;
     
167.         T3.ch = str2;
     
168.         T2.length = strlen(T2.ch);//T2.length=lengthstr(&T2);
     
169.         T3.length = strlen(T3.ch);
     
170.         //initstr(&T2);
     
171.         //creatstr(&T2);
     
172.         //printstr(&T);
     
173.         //concatstr(&T1,&T2);
     
174.         //lengthstr(&T1);
     
175.         //printstr(&T1);
     
176.         //deletesubstr(&T1,4,2);
     
177.         //insertsubstr(&T1,3,T2);
     
178.         //printstr(&T1);
     
179.         //Indexstr(&T1,1,T2);
     
180.         printstr(&T1);
     
181.         replacestr(&T1, T2, T3);
     
182.         printstr(&T1);
     
183.         return 0;
     
184. }
     

复制代码