常用字符串函数模拟实现

1. //模拟实现strlen  
2. #include<stdio.h>  
3. #include<assert.h>  
4. int my_strlen(const char* string)  
5. {  
6.     assert(string != NULL);  
7.     int count = 0;  
8.     while (*string != '\0')  
9.     {  
10.         count++;  
11.         string++;  
12.     }  
13.     return count;  
14. }  
15. int main(void)  
16. {  
17.     char str[]= "abcdef";  
18.     int res = my_strlen(str);  
19.     printf("%d\n", res);  
20.     return 0;  
21. }  
22.   
23.   
24.   
25. //模拟strcpy  
26. #include<stdio.h>  
27. //#include<string.h>  
28. #include<assert.h>  
29. char* my_strcpy(char* str1, const char* str2)  
30. {  
31.     //判断字符串是否有效  
32.     assert(str1 != NULL&&str2 != NULL);  
33.     //保护参数  
34.     char* pStr1 = str1;  
35.     const char* pStr2 = str2;  
36.     while (*pStr2 != '\0')  
37.     {  
38.         *pStr1++ = *pStr2++;  
39.     }  
40.     *pStr1 = '\0';  
41.     return str1;  
42. }  
43. int main(void)  
44. {  
45.     char ar1[] = "abcdef";  
46.     char ar2[] = "def";  
47.     printf("%s\n", ar1);  
48.     my_strcpy(ar1, ar2);  
49.     printf("%s\n", ar1);  
50.     return 0;  
51. }  
52.   
53.   
54.   
55.   
56.   
57.   
58.   
59. //模拟实现strcat  
60. #include<stdio.h>  
61. //#include<string.h>  
62. #include<assert.h>  
63. char* my_strcat(char* str1, const char* str2)  
64. {  
65.     //判断字符串是否有效  
66.     assert(str1 != NULL&&str2 != NULL);  
67.     //保护参数  
68.     char* pStr1 = str1;  
69.     const char* pStr2 = str2;  
70.     while (*pStr1 != '\0')  
71.     {  
72.         *pStr1++;  
73.     }  
74.     while(*pStr2!='\0')  
75.     {  
76.         *pStr1++=*pStr2++;  
77.     }  
78.     *pStr1 = '\0';  
79.     return str1;  
80. }  
81. int main(void)  
82. {  
83.     char ar1[] = "abcdef";  
84.     char ar2[] = "def";  
85.     printf("%s\n", ar1);  
86.     my_strcat(ar1, ar2);  
87.     printf("%s\n", ar1);  
88.     return 0;  
89. }  
90.   
91.   
92.   
93. //模拟实现strcmp  
94. #include<stdio.h>  
95. //#include<string.h>  
96. #include<assert.h>  
97. int my_strcmp(char* str1, const char* str2)  
98. {  
99.     //判断字符串是否有效  
100.     assert(str1 != NULL&&str2 != NULL);  
101.     int res=0;  
102.     while(str1!='\0'||str2!='\0')  
103.     {  
104.         if((res=*str1-*str2)!=0)  
105.         {  
106.             break;  
107.         }  
108.         str1++;  
109.         str2++;  
110.     }  
111.     return res;  
112. }  
113. int main(void)  
114. {  
115.     char ar1[] = "abcdef";  
116.     char ar2[] = "def";  
117.     int t=my_strcmp(ar1, ar2);  
118.     printf("%d\n", t);  
119.     return 0;  
120. }  
121.   
122.   
123.   
124. //模拟实现strstr(查找子串)  
125. #include<stdio.h>  
126. //#include<string.h>  
127. #include<assert.h>  
128. #include <stdlib.h>  
129.   
130. const char* my_strstr(const char* str1, const char* str2)   
131. {  
132.     assert(str1 != NULL && str2 != NULL);//使用断言来判断地址是否合法  
133.     //保护参数（不改变原参数指向位置）   
134.     const char* start = str1;  
135.     const char* tmp = str2;  
136.     const char* check = start;  
137.     while (*start)   
138.     {  
139.         check = start;//标记每次开始查找的地址  
140.         //这个循环是进行字符串1的子字符串和字符串2进行比较  
141.         while (*check == *tmp && *check != '\0' && *tmp != '\0')   
142.         {  
143.             check++;  
144.             tmp++;  
145.         }  
146.         if (*tmp == '\0')   
147.         {  
148.             return start;  
149.         }  
150.         start++;  
151.         tmp = str2;  
152.     }  
153.     return NULL;  
154. }   
155. int main(void)  
156. {  
157.     char ar1[] = "abcdef";  
158.     char ar2[] = "def";  
159.     printf("%s\n", my_strstr(ar1, ar2));  
160.     return 0;  
161. }  
162.   
163.   
164.   
165.   
166.   
167.   
168.   
169. //模拟实现memcpy  
170. #include<stdio.h>  
171. #include<assert.h>  
172. #include <stdlib.h>  
173.   
174. void* my_memcpy(void *dest, const void *src, size_t count)  
175. {  
176.     //判断参数是否有效  
177.     assert(dest!=NULL&&src!=NULL);  
178.     //保护参数  
179.     char* str1=(char*)dest;  
180.     const char* str2=(const char*)src;  
181.     while(count-->0)  
182.     {  
183.         *str1++=*str2++;  
184.     }  
185.     return dest;  
186. }  
187. int main(void)  
188. {  
189.     int ar[] = {1,2,3,4,5,6,7};  
190.     int n=sizeof(ar)/sizeof(ar[0]);  
191.     int br[7];  
192.     my_memcpy(br, ar,sizeof(int)*n);  
193.     for(int i=0;i<n;i++)  
194.     {  
195.         printf("%d",br[i]);  
196.     }  
197.     return 0;  
198. }  
199.   
200.   
201.   
202. //模拟实现memmove  
203. #include<stdio.h>  
204. //#include<string.h>  
205. #include<assert.h>  
206. #include <stdlib.h>  
207.   
208. void* my_memmove(void *dest, const void *src, size_t count)  
209. {  
210.     //判断参数是否有效  
211.     assert(dest!=NULL&&src!=NULL);  
212.     //保护参数  
213.     char* str1=(char*)dest;  
214.     const char* str2=(const char*)src;  
215.     if(str1<=str2||str1>=str2+count)  
216.     {  
217.         while(count-->0)  
218.         {  
219.             *str1++=*str2++;  
220.         }  
221.     }  
222.     else  
223.     {  
224.         str1+=(count-1);  
225.         str2+=(count-1);  
226.         while(count-->0)  
227.         {  
228.             *str1--=*str2--;  
229.         }  
230.     }  
231.     return dest;  
232. }  
233. int main(void)  
234. {  
235.     int ar[] = {1,2,3,4,5,6,7};  
236.     int n=sizeof(ar)/sizeof(ar[0]);  
237.     int br[7];  
238.     my_memmove(br, ar,sizeof(int)*n);  
239.     for(int i=0;i<n;i++)  
240.     {  
241.         printf("%d",br[i]);  
242.     }  
243.     return 0;  
244. }