Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1176916
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
自己实现sprintf

分类： C/C++

2015-12-02 16:46:58

使用c库头文件实现sprintf函数

点击(此处)折叠或打开

  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdarg.h>

  6. int myprintf(const char * format, ...)
  7. {
  8.     va_list ap;
  9.     int ret = -1;
  10.     va_start(ap, format);
  11.     ret = vprintf(format, ap);
  12.     va_end(ap);
  13.     return ret;
  14. }

  16. int mysprintf(char * str, const char * format, ...)
  17. {
  18.     va_list ap;
  19.     int ret = -1;
  20.     va_start(ap, format);
  21.     ret = vsprintf(str, format, ap);
  22.     va_end(ap);
  23.     return ret;
  24. }

  26. int main(int argc, char ** argv)
  27. {
  28.     int    s, l;
  29.     int index1 = 30123456;
  30.     int index2 = 123;
  31.     char    a[5];
  32.     char    b[5];
  33.     char c[12];
  34.     memset(a, 0x00, sizeof(a));
  35.     memset(b, 0x00, sizeof(b));
  36.     memset(c, 0x00, sizeof(c));
  37.     s = snprintf( a, 2, "%d", index2 );
  38.     l = sprintf(b, "%d", index2);
  39.     myprintf("s = [%d], l = [%d]\n", s, l);
  40.     myprintf("a = [%s], b = [%s]\n", a, b);
  41.     mysprintf(c, "%s", "自定义变参函数！");
  42.     printf("c = [%s]\n", c);
  43.     return 0;
  44. }
不使用c库实现sprintf函数

点击(此处)折叠或打开

  1. #include <stdio.h>

  3. typedef char * va_list;
  4. #define va_start(ap,p) (ap = (char *) (&(p)+1))
  5. #define va_arg(ap, type) ((type *) (ap += sizeof(type)))[-1]
  6. #define va_end(ap)

  8. char * strcpy(char * dest,const char *src);
  9. char * strcat(char * dest, const char * src);
  10. unsigned int strlen(const char * s);
  11. void * memset(void * s,int c,unsigned int count);
  12. void * memcpy(void * dest,const void *src,unsigned int count);
  13. int sprintf(char * str, const char *fmt, ...);
  14. void itoa(unsigned int n, char * buf);
  15. int atoi(char* pstr);
  16. void xtoa(unsigned int n, char * buf);
  17. int isDigit(unsigned char c);
  18. int isLetter(unsigned char c);


  21. int main(int argc, char * * argv)
  22. {
  23.         int num = 12;
  24.         char buf[128];
  25.         int hex_num = 15;
  26.         char str[256];
  27.         
  28.         memset(str, 0, sizeof(str));
  29.         memset(buf, 0, sizeof(buf));
  30.         strcpy(buf, "time out");

  32.         printf("OK!\n");
  33.         printf("num=[%d]\n", num);
  34.         printf("buf=[%s]\n", buf);
  35.         printf("hex_num=[%x]\n", hex_num);
  36.     
  37.         sprintf(str, "num=[%d], buf=[%s], hex_num=[%x]", num, buf, hex_num);

  39.         printf("str=[%s]\n", str);

  41.         return 0;
  42. }



  46. /*功能：向字符串 格式化打印一个字符串
  47. *参数：格式化的字符串
  48. *注意：这个是简易版本 (%02x 完成)
  49. * %-3s不行， %f也不行， %X不行
  50. */
  51. int sprintf(char * str, const char *fmt, ...)
  52. {
  53.     int count = 0;
  54.     char c;
  55.     char *s;
  56.     int n;
  57.     
  58.     int index = 0;
  59.     int ret = 2;
  60.     
  61.     char buf[65];
  62.     char digit[16];
  63.     int num = 0;
  64.     int len = 0;
  65.     
  66.     memset(buf, 0, sizeof(buf));
  67.     memset(digit, 0, sizeof(digit));

  69.     va_list ap;
  70.     
  71.     va_start(ap, fmt);
  72.     
  73.     while(*fmt != '\0')
  74.     {
  75.         printf("*fmt=[%c]\n", *fmt);
  76.         if(*fmt == '%')
  77.         {
  78.             fmt++;
  79.             switch(*fmt)
  80.          {
  81.                 case 'd': /*整型*/
  82.                 {
  83.                         n = va_arg(ap, int);
  84.                         if(n < 0)
  85.                         {
  86.                             *str = '-';
  87.                             str++;
  88.                             n = -n;
  89.                         }
  90.                         printf("case d n=[%d]\n", n);
  91.                         itoa(n, buf);
  92.                         printf("case d buf=[%s]\n", buf);
  93.                         memcpy(str, buf, strlen(buf));
  94.                         str += strlen(buf);
  95.                         break;
  96.                 }    
  97.                 case 'c': /*字符型*/
  98.                 {
  99.                         c = va_arg(ap, int);
  100.                         *str = c;
  101.                         str++;
  102.                         
  103.                         break;
  104.                 }
  105.                 case 'x': /*16进制*/
  106.                 {
  107.                         n = va_arg(ap, int);
  108.                         xtoa(n, buf);
  109.                         memcpy(str, buf, strlen(buf));
  110.                         str += strlen(buf);
  111.                         break;
  112.                 }
  113.                 case 's': /*字符串*/
  114.                 {
  115.                         s = va_arg(ap, char *);
  116.                         memcpy(str, s, strlen(s));
  117.                         str += strlen(s);
  118.                         break;
  119.                 }
  120.                 case '%': /*输出%*/
  121.                 {
  122.                     *str = '%';
  123.                     str++;
  124.                     
  125.                     break;
  126.                 }
  127.                 case '0': /*位不足的左补0*/
  128.                 {
  129.                         index = 0;
  130.                         num = 0;
  131.                         memset(digit, 0, sizeof(digit));
  132.                         
  133.                         while(1)
  134.                         {
  135.                                 fmt++;
  136.                                 ret = isDigit(*fmt);
  137.                                 if(ret == 1) //是数字
  138.                                 {
  139.                                         digit[index] = *fmt;
  140.                                         index++;
  141.                                 }
  142.                                 else
  143.                                 {
  144.                                         num = atoi(digit);
  145.                                         break;
  146.                                 }
  147.                         }
  148.                         switch(*fmt)
  149.                      {
  150.                                 case 'd': /*整型*/
  151.                                 {
  152.                                         n = va_arg(ap, int);
  153.                                         if(n < 0)
  154.                                         {
  155.                                             *str = '-';
  156.                                             str++;
  157.                                             n = -n;
  158.                                         }    
  159.                                         itoa(n, buf);
  160.                                         len = strlen(buf);
  161.                                         if(len >= num)
  162.                                         {
  163.                                                 memcpy(str, buf, strlen(buf));
  164.                                                 str += strlen(buf);
  165.                                         }
  166.                                         else
  167.                                         {
  168.                                                 memset(str, '0', num-len);
  169.                                                 str += num-len;
  170.                                                 memcpy(str, buf, strlen(buf));
  171.                                                 str += strlen(buf);
  172.                                         }
  173.                                         break;
  174.                                 }    
  175.                                 case 'x': /*16进制*/
  176.                                 {
  177.                                         n = va_arg(ap, int);
  178.                                         xtoa(n, buf);
  179.                                         len = strlen(buf);
  180.                                         if(len >= num)
  181.                                         {
  182.                                                 memcpy(str, buf, len);
  183.                                                 str += len;
  184.                                         }            
  185.                                         else
  186.                                         {
  187.                                                 memset(str, '0', num-len);
  188.                                                 str += num-len;
  189.                                                 memcpy(str, buf, len);
  190.                                                 str += len;
  191.                                         }
  192.                                         break;
  193.                                 }
  194.                                 case 's': /*字符串*/
  195.                                 {
  196.                                         s = va_arg(ap, char *);
  197.                                         len = strlen(s);
  198.                                         if(len >= num)
  199.                                         {
  200.                                                 memcpy(str, s, strlen(s));
  201.                                                 str += strlen(s);
  202.                                         }
  203.                                         else
  204.                                         {
  205.                                                 memset(str, '0', num-len);
  206.                                                 str += num-len;
  207.                                                 memcpy(str, s, strlen(s));
  208.                                                 str += strlen(s);
  209.                                         }
  210.                                         break;
  211.                                 }
  212.                                 default:
  213.                                         break;
  214.                         }
  215.                 }
  216.                 default:
  217.                         break;
  218.             }
  219.         }
  220.         else
  221.         {
  222.             *str = *fmt;
  223.             str++;
  224.             
  225.             if(*fmt == '\n')
  226.             {
  227.                     
  228.             }
  229.         }
  230.         fmt++;
  231.     }

  233.     va_end(ap);

  235.     return count;
  236. }

  238. /*
  239. *功能：整型(int) 转化成 字符型(char)
  240. *注意：不用 % / 符号的话，只能正确打印:0...9的数字对应的字符'0'...'9'
  241. */
  242. void itoa(unsigned int n, char * buf)
  243. {
  244.         int i;
  245.         
  246.         if(n < 10)
  247.         {
  248.                 buf[0] = n + '0';
  249.                 buf[1] = '\0';
  250.                 return;
  251.         }
  252.         itoa(n / 10, buf);

  254.         for(i=0; buf[i]!='\0'; i++);
  255.         
  256.         buf[i] = (n % 10) + '0';
  257.         
  258.         buf[i+1] = '\0';
  259. }

  261. /*
  262. *功能：字符型(char) 转化成 整型(int)
  263. */
  264. int atoi(char* pstr)
  265. {
  266.         int int_ret = 0;
  267.         int int_sign = 1; //正负号标示 1:正数 -1:负数
  268.         
  269.         if(pstr == '\0') //判断指针是否为空
  270.         {
  271.                 return -1;
  272.         }
  273.         while(((*pstr) == ' ') || ((*pstr) == '\n') || ((*pstr) == '\t') || ((*pstr) == '\b'))
  274.         {
  275.                 pstr++; //跳过前面的空格字符
  276.         }
  277.         
  278.         /*
  279.         * 判断正负号
  280.         * 如果是正号，指针指向下一个字符
  281.         * 如果是符号，把符号标记为Integer_sign置-1，然后再把指针指向下一个字符
  282.         */
  283.         if(*pstr == '-')
  284.         {
  285.                 int_sign = -1;
  286.         }
  287.         if(*pstr == '-' || *pstr == '+')
  288.         {
  289.                 pstr++;
  290.         }
  291.         
  292.         while(*pstr >= '0' && *pstr <= '9') //把数字字符串逐个转换成整数，并把最后转换好的整数赋给Ret_Integer
  293.         {
  294.                 int_ret = int_ret * 10 + *pstr - '0';
  295.                 pstr++;
  296.         }
  297.         int_ret = int_sign * int_ret;
  298.         
  299.         return int_ret;
  300. }

  302. /*
  303. *功能：16进制字(0x) 转化成 字符型(char)
  304. *注意：不用 % / 符号的话，只能正确打印，0...9..15的数字,对应的'0'...'9''A'...'F'
  305. *注意：由于编译问题，这个函数，暂时由uart_sendByte_hex()函数替代
  306. */
  307. void xtoa(unsigned int n, char * buf)
  308. {
  309.         int i;
  310.         
  311.         if(n < 16)
  312.         {
  313.                 if(n < 10)
  314.                 {
  315.                         buf[0] = n + '0';
  316.                 }
  317.                 else
  318.                 {
  319.                         buf[0] = n - 10 + 'a';
  320.                 }
  321.                 buf[1] = '\0';
  322.                 return;
  323.         }
  324.         xtoa(n / 16, buf);
  325.         
  326.         for(i = 0; buf[i] != '\0'; i++);
  327.         
  328.         if((n % 16) < 10)
  329.         {
  330.                 buf[i] = (n % 16) + '0';
  331.         }
  332.         else
  333.         {
  334.                 buf[i] = (n % 16) - 10 + 'a';
  335.         }
  336.         buf[i + 1] = '\0';
  337. }

  339. /*
  340.  * 判断一个字符是否数字
  341.  */
  342. int isDigit(unsigned char c)
  343. {
  344.     if (c >= '0' && c <= '9')
  345.         return 1;
  346.     else
  347.         return 0;
  348. }

  350. /*
  351.  * 判断一个字符是否英文字母
  352.  */
  353. int isLetter(unsigned char c)
  354. {
  355.     if (c >= 'a' && c <= 'z')
  356.         return 1;
  357.     else if (c >= 'A' && c <= 'Z')
  358.         return 1;
  359.     else
  360.         return 0;
  361. }

  363. /**
  364.  * memset - Fill a region of memory with the given value
  365.  * @s: Pointer to the start of the area.
  366.  * @c: The byte to fill the area with
  367.  * @count: The size of the area.
  368.  *
  369.  * Do not use memset() to access IO space, use memset_io() instead.
  370.  */
  371. void * memset(void * s,int c,unsigned int count)
  372. {
  373.     char *xs = (char *) s;

  375.     while (count--)
  376.         *xs++ = c;

  378.     return s;
  379. }

  381. /**
  382.  * strcpy - Copy a %NUL terminated string
  383.  * @dest: Where to copy the string to
  384.  * @src: Where to copy the string from
  385.  */
  386. char * strcpy(char * dest,const char *src)
  387. {
  388.     char *tmp = dest;

  390.     while ((*dest++ = *src++) != '\0')
  391.         /* nothing */;
  392.     return tmp;
  393. }


  396. /**
  397.  * strlen - Find the length of a string
  398.  * @s: The string to be sized
  399.  */
  400. unsigned int strlen(const char * s)
  401. {
  402.     const char *sc;

  404.     for (sc = s; *sc != '\0'; ++sc)
  405.         /* nothing */;
  406.     return sc - s;
  407. }

  409. /**
  410.  * strcat - Append one %NUL-terminated string to another
  411.  * @dest: The string to be appended to
  412.  * @src: The string to append to it
  413.  */
  414. char * strcat(char * dest, const char * src)
  415. {
  416.     char *tmp = dest;

  418.     while (*dest)
  419.         dest++;
  420.     while ((*dest++ = *src++) != '\0')
  421.         ;

  423.     return tmp;
  424. }

阅读(11455) | 评论(0) | 转发(0) |
0

上一篇：rename函数

下一篇：ntohl,htonl函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6