未确定参数数目的函数编写

今天看<<the c++ programming language>>的时候看到了这个内容，就试着编写一个类似c下面的printf函数，虽然是实现了，但是效率好像不是很好，现在贴出我今晚的一个小成果。

 

1. /*
2. 题目: MyPrint
3. 作者: sgx
4. 日期: 2008-11-4
5. IDE:  vc6.0
6. */
7. #include <iostream> 
8. #include <cstdarg>//必须的头文件，编写不确定参数要用到里面的宏
9. #include <assert.h>
10. using namespace std; 
12. void MyPrint(const char* ...);
13. int str_copy2(const char* ,char*);
15. int main() 
16. { 
17.     int i=12;
18.     char c='c';
19.     char str[]="love";
20.     long il=35;
21.     double id=35.001;
22.     float ff=351.015f;
23.     
24.     MyPrint("cniksd/n");
25.     MyPrint("my no is #n/n",&i,NULL);//最后要传递一个NULL控制结束
26.     MyPrint("c=#c,str=#s,il=#l,id=#d,ff=#f/n",&c,str,&il,&id,&ff,NULL);
28.     system("PAUSE");
29.     return 0;
30. }
32. void MyPrint(const char* print_str  ...)
33. {
34.     bool no_arg = false;
35.     const char* p_str=print_str;
36.     char symbol[3];//用于接收特别的字符，以确定输出类型
37.     /*
38.     #n 整形，
39.     #l 长整形，
40.     #c 字符型
41.     #s 字符串
42.     #d double
43.     #f float*/
45.     va_list print_list;  //创建一个表把未知参数载入
46.     va_start(print_list,print_str);
47.     
48.     while(*p_str!='/0')
49.     {
50.         if(*p_str=='#')
51.         {
52.             int i = str_copy2(p_str,symbol);
53.             if(!no_arg && i == 2)
54.             {
55.                 switch(symbol[1])
56.                 {
57.                 case 'n':
58.                     {
59.                         int* pn = va_arg(print_list,int*);//指定参数类型
60.                         if(pn != NULL)
61.                         {
62.                             cout<<*pn;
63.                         }
64.                         else
65.                             no_arg=true;
66.                     }
67.                     break;
68.                 case 'l':
69.                     {
70.                         long* pl = va_arg(print_list,long*);//指定参数类型
71.                         if(pl != NULL)
72.                         {
73.                             cout<<*pl;
74.                         }
75.                         else
76.                             no_arg=true;
77.                     }
78.                     break;
79.                 case 'c':
80.                     {
81.                         char* pc = va_arg(print_list,char*);//指定参数类型
82.                         if(pc != NULL)
83.                         {
84.                             cout<<pc[0];
85.                         }
86.                         else
87.                             no_arg=true;
88.                     }
89.                     break;
90.                 case 's':
91.                     {
92.                         char* ps = va_arg(print_list,char*);//指定参数类型
93.                         if(ps != NULL)
94.                         {
95.                             cout<<*ps;
96.                         }
97.                         else
98.                             no_arg=true;
99.                     }
100.                     break;
101.                 case 'd':
102.                     {
103.                         double* pd = va_arg(print_list,double*);//指定参数类型
104.                         if(pd != NULL)
105.                         {
106.                             cout<<*pd;
107.                         }
108.                         else
109.                             no_arg=true;
110.                     }
111.                     break;
112.                 case 'f':
113.                     {
114.                         float* pf = va_arg(print_list,float*);//指定参数类型
115.                         if(pf != NULL)
116.                         {
117.                             cout<<*pf;
118.                         }
119.                         else
120.                             no_arg=true;
121.                     }
122.                     break;
123.                 default:
124.                     cout<<symbol[1];
125.                 }
126.             }
127.             p_str+=i;
128.         }
129.         else
130.         {
131.             cout<<p_str[0];
132.             p_str++;
133.         }
134.     }
136.     va_end(print_list);//对参数清理
137. } 
139. int str_copy2(const char* sour,char* dest)//把两个字符复制到dest中
140. {
141.     int i=0;
142.     assert(sour!=NULL && dest!=NULL);
143.     
144.     while(*sour != ' ' && *sour!='/0')
145.     {
146.         *dest++ = *sour++;
147.         i++;
148.         if(i==2)break;//只复制两个字符
149.     }
150.     *dest='/0';
151.     
152.     return i;
153. }