自定义打印输出函数格式，模拟printf函数

[cpp] view plaincopyhttp://blog.csdn.net/sunrier/article/details/6730138

1. /*************************************************************   
2.     FileName : testPrintfFunction.cpp 
3.     FileFunc : printf参数模拟  
4.     Version  : V0.1   
5.     Author   : Sunrier   
6.     Date     : 2011-08-29 
7.     Descp    : 简单模拟printf函数 
8. *************************************************************/  
9. #include <stdio.h>   
10. #include <stdarg.h>  
11. #include <stdlib.h>//itoa()......  
12. #include <string.h>  
13. #include <math.h>  
14. #include <ctype.h>  
15.   
16.   
17. #define     MAXBUF      15  
18.   
19. #define     DEFAULT_PRECI       3   //符点型默认精度  
20.    
21.    
22. int add(const int ,...);  
23.   
24. int myPrintf(const char *, ...);  
25.   
26. void ftoa(double InputData, char *OutputData,int  DEFAULT_Vaule);  
27.   
28. int main ( void )  
29. {     
30.     int x,y;  
31.   
32.     //int x1=0xFEd278df;  
33.     int x1=8989;  
34.     double doubleData=89.78623;  
35.       
36.     int x3=0;  
37.     char *s1="1234567";  
38.       
39.     x = add(4,1,2,3,4);  
40.   
41.     y = add(3,1,2,3);  
42.   
43.     printf("x=%B\n",x);  
44.   
45.     printf("y=%3\n",y);   
46.   
47.     myPrintf("Hello Sunrier!\n");  
48.   
49.     myPrintf("wwwwwwwww");  
50.   
51.     myPrintf("%s\n",s1);  
52.   
53.     myPrintf("x3=%x\n",x3);  
54.   
55.     myPrintf("x=%b\n",x);  
56.     printf("x1=%b\n",x1);  
57.     myPrintf("x1=%b\n",x1);  
58.   
59.     myPrintf("x1=0x%x s=%s y=%d\n",x1,s1,y);  
60.   
61.     myPrintf("doubleData=%f\n",doubleData);  
62.     myPrintf("doubleData=%3f\n",doubleData);  
63.     printf("doubleData=%3f\n",s1);  
64.           
65.     return 0;  
66. }  
67.    
68.   
69.   
70. int add(const int n,...)  
71. {  
72.     va_list arg;//定义va_list类型变量arg  
73.   
74.     va_start(arg,n);//arg初始化,n是第一个可见参数名字;使arg指向第一个可选参数  
75.       
76.     int sum=0;  
77.     int tmp =0;  
78.     for(int i=0;i<n;i++)  
79.     {  
80.         tmp=va_arg(arg,int);//返回参数列表中的当前参数并使arg指向参数列表中的下一个参数  
81.         sum+=tmp;  
82.     }  
83.       
84.     va_end(arg);//把arg指针清为NULL  
85.       
86.     return sum;  
87. }  
88.   
89.   
90.   
91. int myPrintf(const char *format, ...)  
92. {  
93.     va_list ap;  
94.     va_start(ap,format);  
95.       
96.     //STRING  
97.     //char ch;  
98.      const char *str;  
99.      //const char *str1;  
100.       
101.     //OCT  
102.     int value ;  
103.     char buf[MAXBUF];  
104.   
105.     //HEX  
106.     int offset;  
107.     unsigned char ucI,ucLen;  
108.     unsigned long ulValue;  
109.     //unsigned char ucBuf[MAXBUF];  
110.     //unsigned long *ulpValue;  
111.   
112.     //FLOAT  
113.     double fdata;  
114.   
115.     //BINARY  
116.   
117.   
118.       
119.     while(*format)  
120.     {  
121.         if('%'!=*format)  
122.         {  
123.             putchar(*format++);  
124.             continue;  
125.         }  
126.   
127.         switch(*++format)  
128.         {  
129.             case    's':  
130.                         str = NULL;  
131.                         str=va_arg(ap, const char *);  
132.                         for(;*str!='\0';str++)  
133.                         {  
134.                             putchar(*str);  
135.                         }  
136.                         ++format;//越过当前参数，移到下一个参数  
137.                         break;  
138.   
139.             case    'd':  
140.                         value=va_arg(ap,const int);  
141.                         memset(buf,0,sizeof(buf));  
142.                         itoa(value, buf, 10);  
143.                         for (str=buf ;*str!='\0'; str++)   
144.                         {  
145.                             putchar(*str);  
146.                         }  
147.                         ++format;  
148.                         break;  
149.             case    'x':  
150.                         offset = 0;  
151.                         ucLen = 0 ;  
152.                         ulValue=va_arg(ap,const int);  
153.                         memset(buf,0,sizeof(buf));  
154.   
155.                         if( !ulValue )  
156.                         {  
157.                             buf[ucLen] = ulValue ;  
158.                             str = buf ;  
159.                             putchar((*str+48));  
160.                             ++format;  
161.                             break;  
162.                         }  
163.   
164.                         for( ucI=0;ucI<MAXBUF;ucI++)  
165.                         {  
166.                             if( pow(16,ucI)>ulValue )  
167.                             {  
168.                                 ucLen = ucI;  
169.                                 break;  
170.                             }  
171.                         }  
172.                           
173.                           
174.                         for( ucI=0;ucI<ucLen;ucI++)  
175.                         {  
176.   
177.                             buf[ucI] = ulValue/pow(16,ucLen-ucI-1) ;  
178.                             ulValue = ulValue%(unsigned long)pow(16,ucLen-ucI-1);  
179.   
180.                         }  
181.                           
182.                         //puts("0x");  
183.                         for (str=buf ;*str!='\0'; str++)   
184.                         {  
185.                             if( (*str>=0) && (*str<=9) )  
186.                             {  
187.                                 putchar((*str+48));  
188.                             }  
189.                             else  
190.                             {  
191.                                 putchar((*str+87));  
192.                             }  
193.                         }  
194.                         ++format;  
195.                         break;  
196.             case    'X':  
197.                         offset = 0;  
198.                         ucLen = 0 ;  
199.                         ulValue=va_arg(ap,const int);  
200.                         memset(buf,0,sizeof(buf));  
201.   
202.                           
203.                         if( !ulValue )  
204.                         {  
205.                             buf[ucLen] = ulValue ;  
206.                             str = buf ;  
207.                             putchar((*str+48));  
208.                             ++format;  
209.                             break;  
210.                         }  
211.   
212.                         for( ucI=0;ucI<MAXBUF;ucI++)  
213.                         {  
214.                             if( pow(16,ucI)>ulValue )  
215.                             {  
216.                                 ucLen = ucI;  
217.                                 break;  
218.                             }  
219.                         }  
220.                           
221.                           
222.                         for( ucI=0;ucI<ucLen;ucI++)  
223.                         {  
224.   
225.                             buf[ucI] = ulValue/pow(16,ucLen-ucI-1) ;  
226.                             ulValue = ulValue%(unsigned long)pow(16,ucLen-ucI-1);  
227.   
228.                         }  
229.                           
230.                         //puts("0X");  
231.                         for (str=buf ;*str!='\0'; str++)   
232.                         {  
233.                             if( (*str>=0) && (*str<=9) )  
234.                             {  
235.                                 putchar((*str+48));  
236.                             }  
237.                             else  
238.                             {  
239.                                 putchar((*str+55));  
240.                             }  
241.                         }  
242.                         ++format;  
243.                         break;  
244.             case    'f':  
245.                         fdata = va_arg(ap, double);  
246.                         memset(buf,0,sizeof(buf));  
247.                         ftoa(fdata, buf, DEFAULT_PRECI);  
248.                         for (str=buf ;*str!='\0'; str++)   
249.                         {  
250.                             putchar(*str);  
251.                         }  
252.                         ++format;  
253.                         break;  
254.             case    '.':  
255.                         if( isdigit(*++format) )  
256.                         {  
257.                             if( 'f'==(*++format) )  
258.                             {  
259.                                 --format;  
260.                                 fdata = va_arg(ap, double);  
261.                                 memset(buf,0,sizeof(buf));  
262.                                 int preci =*format-'0';   
263.                                 ftoa(fdata, buf, preci);  
264.                                 for (str=buf ;*str!='\0'; str++)   
265.                                 {  
266.                                     putchar(*str);  
267.                                 }  
268.                                 ++format;  
269.                                 ++format;  
270.                             }  
271.                         }  
272.                         else  
273.                         {  
274.                             --format;  
275.                             if( 'f'==(*++format) )  
276.                             {  
277.                                 fdata = va_arg(ap, double);  
278.                                 memset(buf,0,sizeof(buf));  
279.                                 int preci =1;   
280.                                 ftoa(fdata, buf, preci);  
281.                                 for (str=buf ;*str!='\0'; str++)   
282.                                 {  
283.                                     putchar(*str);  
284.                                 }  
285.                                 ++format;  
286.                             }  
287.                         }  
288.                         break;  
289.             case    'b':  
290.                         value=va_arg(ap,const int);  
291.                         memset(buf,0,sizeof(buf));  
292.                         itoa(value, buf, 2);  
293.                         for (str=buf ;*str!='\0'; str++)   
294.                         {  
295.                             putchar(*str);  
296.                         }  
297.                         ++format;  
298.                         break;  
299.           
300.   
301.             default :     
302.                         break;  
303.           
304.         }  
305.   
306.           
307.   
308.     }  
309.       
310.     va_end(ap);  
311.   
312.     return 0;  
313. }  
314.   
315.   
316.   
317. const double eps = 1e-12;  
318.    
319. char s[30];  
320.    
321. void reverse(char *s)  
322. {  
323.      int i , j;  
324.      int len = strlen(s);  
325.      for( i = 0 , j = len - 1 ; i < j ; i++ , j--)  
326.          s[i]^=s[j]^=s[i]^=s[j];  
327. }  
328.    
329. /* ftoa:   convert double n to string s with digits*/  
330. void ftoa(double n, char *s,  int  digits)  
331. {  
332.      memset(s , 0 , sizeof(s));  
333.      int i = 0 , p;  
334.      bool sign = true;  
335.      if( n < 0 )   
336.      {   
337.          sign = false;  
338.          n = -n;  
339.      }  
340.      long   t = ( long)n;  
341.      n = n - t;  
342.      if( t == 0)  
343.      {  
344.          s[i++] = '0';  
345.      }  
346.      else  
347.      {  
348.          while( t != 0 )  
349.          {  
350.              p = t % 10;  
351.              t /= 10;  
352.              s[i++] = p + '0';  
353.          }  
354.          if(!sign) s[i++] = '-';  
355.          reverse(s);  
356.      }  
357.      if( fabs( n - 0.0 ) > eps )  
358.      {  
359.          s[i++] = '.';  
360.          int cur_d = 0;  
361.          while( cur_d < digits)  
362.          {  
363.              cur_d++;  
364.              n *= 10.0;  
365.              p = (long )n;  
366.              n = n - p;  
367.              s[i++] = p + '0';  
368.          }  
369.      }  
370.      s[i] = '\0';  
371. }  

(转自)http://blog.csdn.net/sunrier/article/details/6730138