C语言部分函数原型实现

学习、研究库函数的实现，能使你考虑问题更加严谨、全面，培养良好的编程风格和习惯

最近想学习一下C语言库函数的内部实现，于是自己简单地写了几个

贴出以下代码，希望大家能够帮忙指正、优化、完善，

特别是考虑不周和执行效率上给出指导意见

阅读本文前，可以先参考本博客的上一篇文章 C语言函数小集合

 

调试环境： VS2008（C）

[cpp:showcolumns] view plaincopyprint?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. // sysFunc.cpp : Defines the entry point for the console application.   
2. //   
3. #include "stdafx.h"   
4. #include <ctype.h>   
5. /**************************************/  
6. /**********     isalnum()     *********/  
7. /**************************************/  
8. int m_isalnum(char ch)  
9. {  
10.     return ((ch<='9'&&ch>='0')  
11.             ||(ch<='z'&&ch>='a')  
12.             ||(ch<='Z'&&ch>='A'));   
13. }  
14. void fun_isalnum()  
15. {  
16.     char str[]="A12a;D*s06";  
17.     int i;  
18.     printf("Test isalnum.: %s/n", str);  
19.     for(i=0; str[i]!=NULL; i++) /* #define NULL 0 */  
20.     {  
21.         if(m_isalnum(str[i])) /* isalnum(str[i]) */  
22.             printf("%c is a number or character./n", str[i]);  
23.     }  
24. }  
25. /**************************************/  
26. /**********     isalpha()     *********/  
27. /**************************************/  
28. int m_isalpha(char ch)  
29. {  
30.     return ((ch<='z'&&ch>='a')  
31.             ||(ch<='Z'&&ch>='A'));   
32. }  
33. void fun_isalpha()  
34. {  
35.     char str[]="A12a;D*s06";  
36.     int i;  
37.     printf("/nTest isalpha: %s/n", str);  
38.     for(i=0; str[i]!='/0'; i++)  
39.     {  
40.         if(m_isalpha(str[i])) /* isalpha(str[i]) */  
41.             printf("%c is a character./n", str[i]);  
42.     }  
43. }  
44. /**************************************/  
45. /**********     islower()     *********/  
46. /**************************************/  
47. int m_islower(char ch)  
48. {  
49.     return (ch<='z'&&ch>='a');  
50. }  
51. void fun_islower()  
52. {  
53.     char str[]="A12a;D*s06";  
54.     int i;  
55.     printf("/nTest islower: %s/n", str);  
56.     for(i=0; str[i]!='/0'; i++)  
57.     {  
58.         if(m_islower(str[i])) /* isalpha(str[i]) */  
59.             printf("%c is a lower character./n", str[i]);  
60.     }  
61. }  
62. /**************************************/  
63. /**********     isupper()     *********/  
64. /**************************************/  
65. int m_isupper(char ch)  
66. {  
67.     return (ch<='Z'&&ch>='A');  
68. }  
69. void fun_isupper()  
70. {  
71.     char str[]="A12a;D*s06";  
72.     int i;  
73.     printf("/nTest isupper: %s/n", str);  
74.     for(i=0; str[i]!='/0'; i++)  
75.     {  
76.         if(m_isupper(str[i])) /* isalpha(str[i]) */  
77.             printf("%c is a isupper character./n", str[i]);  
78.     }  
79. }  
80. /**************************************/  
81. /**********     isxdigit()    *********/  
82. /**************************************/  
83. int m_isxdigit(char ch)  
84. {  
85.     return (ch<='9'&&ch>='0');  
86. }  
87. void fun_isxdigit()  
88. {  
89.     char str[]="A12a;D*s06";  
90.     int i;  
91.     printf("/nTest isxdigit: %s/n", str);  
92.     for(i=0; str[i]!='/0'; i++)  
93.     {  
94.         if(m_isxdigit(str[i])) /* isalpha(str[i]) */  
95.             printf("%c is a isxdigit character./n", str[i]);  
96.     }  
97. }  
98. /**************************************/  
99. /**********     tolower()     *********/  
100. /**************************************/  
101. char m_tolower(char ch)  
102. {  
103.     if(ch<='Z'&&ch>='A')  
104.         return (ch+'a'-'A');  
105.     return '0';  
106. }  
107. void fun_tolower()  
108. {  
109.     char str[]="A12a;D*s06";  
110.     int i;  
111.     char ch;   
112.     printf("/nTest tolower: %s/n", str);  
113.     for(i=0; str[i]!='/0'; i++)  
114.     {  
115.         ch=str[i];  
116.         if(m_isalpha(ch)) /* isalpha(str[i]) */  
117.         {  
118.             if(ch<='Z'&&ch>='A')  
119.                 ch=m_tolower(ch);  
120.             printf("%c is a tolower character./n", ch);  
121.         }  
122.     }  
123. }  
124. /**************************************/  
125. /**********     toupper()     *********/  
126. /**************************************/  
127. char m_toupper(char ch)  
128. {  
129.     if(ch<='z'&&ch>='a')  
130.         return (ch+'A'-'a');  
131.     return '0';  
132. }  
133. void fun_toupper()  
134. {  
135.     char str[]="A12a;D*s06";  
136.     int i;  
137.     char ch;  
138.     printf("/nTest toupper: %s/n", str);  
139.     for(i=0; str[i]!='/0'; i++)  
140.     {  
141.         ch=str[i];  
142.         if(m_isalpha(ch)) /* isalpha(str[i]) */  
143.         {  
144.             if(ch<='z'&&ch>='a')  
145.                 ch=m_toupper(ch);  
146.             printf("%c is a toupper character./n", ch);  
147.         }  
148.     }  
149. }  
150. /**************************************/  
151. /**********       atoi()      *********/  
152. /**************************************/  
153. int m_atoi(char *str)  
154. {  
155.     char *s=str;  
156.     int sum=0, flag=1;  
157.     if(*s==NULL)  
158.         return 0;  
159.     while(*s==' ') /* skip space */  
160.         s++;   
161.     if(*s=='-')  
162.     {  
163.         flag=-1;  
164.         s++;  
165.     }  
166.     while(*s!='/0' && m_isxdigit(*s))  
167.     {  
168.         sum=*s-'0'+sum*10;  
169.         s++;  
170.     }  
171.       
172.     return flag*sum;  
173. }  
174. void fun_atoi()  
175. {  
176.     char str[]="   -123.456def";  
177.     printf("/nTest atoi.../n");  
178.     printf("%s char to int: %d/n", str, m_atoi(str));  
179. }  
180. /**************************************/  
181. /**********       itoa()      *********/  
182. /**************************************/  
183. void m_itoa(int n)  
184. {  
185.     char *s=NULL;  
186.     int i, j, mod, flag=0;  
187.     char num[20];  
188.     if(n<0)   
189.     {  
190.         flag=1;  
191.         n=-n;  
192.     }  
193.     i=0;  
194.     do   
195.     {  
196.         mod=n%10;  
197.         n=n/10;       
198.         num[i++]=mod+'0';  
199.     } while (n>0);  
200.       
201.     if(flag) /* print '-' */  
202.         printf("-");  
203.     for(j=i-1; j>=0; j--) /* print reverse char */  
204.     {  
205.         printf("%c", num[j]);  
206.     }  
207. }  
208. void fun_itoa()  
209. {  
210.     int n=1234;  
211.     printf("/nTest itoa.../n");  
212.     printf("%d char to int: ", n);  
213.     m_itoa(n);  
214.     printf("/n");  
215. }  
216. /**************************************/  
217. /**********       atof()      *********/  
218. /**************************************/  
219. float m_atof(char *str)  
220. {  
221.     char *s=str;  
222.     if(*s=='/0')  
223.         return 0.0;  
224.       
225.     float sum=0.0;  
226.     int flag=1, pow=0;  
227.     if(*s=='-')  
228.     {  
229.         flag=-1;  
230.         s++;  
231.     }  
232.     while(*s!='/0')  
233.     {  
234.         if(*s=='.') /* dot */  
235.         {  
236.             pow=1;  
237.             s++;  
238.             continue;  
239.         }  
240.         sum=*s-'0'+sum*10;  
241.         pow*=10;  
242.         s++;  
243.     }  
244.     return flag*sum/pow;  
245. }  
246. void fun_atof()  
247. {  
248.     char str[]="-123.345";  
249.     printf("/nTest atof.../n");  
250.     printf("%s char to int: %f/n", str, m_atof(str));  
251. }  
252. /**************************************/  
253. /**********       ftoa()      *********/  
254. /**************************************/  
255. void m_ftoa(float n)  
256. {  
257.     char num[20];  
258.     int i, j, val, mod, flag, pow;  
259.     float dot;  
260.     if(n<-1e-6)  
261.     {  
262.         flag=1;  
263.         n=-n;  
264.     }  
265.     i=0;  
266.     val=(int)n; /* integer */  
267.     dot=n-val;  /* decimal */  
268.     do  
269.     {  
270.         mod=val%10;  
271.         val=val/10;  
272.         num[i++]=mod+'0';  
273.     }while(val>0);  
274.     if(dot>1e-6)  
275.     {  
276.         num[i]='.';  
277.         pow=10;  
278.     }  
279.     do   
280.     {  
281.         dot=dot*pow;  
282.         mod=(int)dot;  
283.         num[i++]=mod+'0';  
284.         dot=dot-mod; /* error, why, float... help me */  
285.     } while (dot>1e-6);  
286.     if(flag)  
287.         printf("-");  
288.     for(j=i-1; j>=0; j--)  
289.         printf("%c", num[j]);  
290. }  
291. void fun_ftoa()   
292. {  
293.     float n=-1234.5678;  
294.     printf("/nTest ftoa.../n");  
295.     printf("%d char to int: ", n);  
296.     m_ftoa(n);  
297.     printf("/n");  
298. }  
299. /**************************************/  
300. /**********       main()      *********/  
301. /**************************************/  
302. int _tmain(int argc, _TCHAR* argv[])  
303. {  
304.     fun_isalnum();  
305.     fun_isalpha();  
306.     fun_islower();  
307.     fun_isupper();  
308.     fun_isxdigit();  
309.     fun_tolower();  
310.     fun_toupper();  
311.     fun_atof();  
312.     fun_atoi();  
313.     fun_itoa();  
314.     fun_ftoa();  
315.     return 0;  
316. }  

运行结果：