重写sprintf

最新推荐文章于 2023-03-22 00:08:39 发布
最新推荐文章于 2023-03-22 00:08:39 发布
阅读量377 收藏
点赞数
文章标签： ui

需要几个理由：
1、sprintf不能返回格式化结果串的实际长度
2、sprintf总是把NULL指针格式化为(null)
3、sprintf的%S格式化只能处理UNICODE到SBCS转换，不能处理UNICODE到MBCS的转换
4、sprintf处理浮点数，一不小心就拖出个长长的尾巴来

格式串的规则定义
//%[flag] [width] [.precision] [{h | l | I64 | L}]type
//flags: -,+,0,' ',#
//width:
//precision
//type:c,C,d,i,o,u,x,X,e,E,f,g,s,S

//定义扫描机的状态
typedef enum{
    XS_SKIP = 0,     //扫描前缀串
    XS_PROC = 1,     //需处理当前格式或前缀串
    XS_FLAG = 2,     //扫描添位符
    XS_WIDTH = 3,     //扫描占宽
    XS_PREC = 4,     //扫描精度
    XS_SIZE= 5,     //扫描整形指示
    XS_TYPE = 6,     //扫描格式符
    XS_TERM = 7     //扫描终止
}XF_STATUS;

//定义扫描机的动作
typedef enum{
    XO_PAUSE = 0,    //暂停
    XO_CONTINUE = 1    //继续
}XF_OPERA;

//判断是否添位符
#define s_is_flag(ch)    ((ch == '0' || ch == ' ' || ch == '#')? 1 : 0)
//判断是否是数字
#define s_is_digit(ch)    ((ch >= '0' && ch <= '9')? 1 : 0)
//判断是否是整形指示
#define s_is_size(ch)    ((*token == 'h' || *token == 'l')? 1 : 0)
//判断是否是格式符
#define s_is_type(ch)    ((ch == 'c' || ch == 'C' || ch == 'd' || ch == 'u' || ch == 'x' || ch == 'X' || ch == 'f'|| ch == 's' || ch == 'S')? 1 : 0)

int xsprintf(char* buf,const char* fmt,...)
{
    va_list arg;
    int total = 0;
    char xf_flag = 0;
    int xf_width = 0;
    int xf_prec = 0;
    char xf_size = 0;
    char xf_type = 0;
    char tk_width[NUM_LEN + 1],tk_prec[NUM_LEN + 1];
    int width_count = 0;
    int prec_count = 0;
    int tk_count = 0;

    //初始化
    XF_STATUS xs = XS_SKIP;
    XF_OPERA xo = XO_PAUSE;

    char* token = (char*)fmt;

    va_start(arg,fmt);

    while(xs != XS_TERM)
    {
        switch(xs)
        {
        case XS_SKIP:
            if(*token == '%' && *(token + 1) != '%')
            {
                if(!tk_count)
                {
                    xs = XS_FLAG; //没有前缀串则过渡到格式串扫描
                    xo = XO_CONTINUE;
                }else
                {
                    xs = XS_PROC; //有前缀串则先处理前缀串
                    xo = XO_PAUSE;
                }
            }else if(*token == '\0')
            {
                xs = XS_PROC; //过渡到处理前缀串
                xo = XO_PAUSE;
            }else
            {
                xs = XS_SKIP; //继续前缀串扫描
                xo = XO_CONTINUE;
            }
            break;
        case XS_FLAG:
            if(s_is_flag(*token))
            {
                xf_flag = *token;
                xs = XS_FLAG; //继续占位符扫描
                xo = XO_CONTINUE;
            }else
            {
                xs = XS_WIDTH; //过渡到占位宽扫描
                xo = XO_PAUSE;
            }
            break;
        case XS_WIDTH:
            if(s_is_digit(*token))
            {
                tk_width[width_count ++] = *token;
                xs = XS_WIDTH; //继续占位宽扫描
                xo = XO_CONTINUE;
            }else if(*token == '.')
            {
                xs = XS_PREC; //过渡到精度扫描
                xo = XO_CONTINUE;
            }else
            {
                xs = XS_SIZE; //过渡到整形指示扫描
                xo = XO_PAUSE;
            }
            break;
        case XS_PREC:
            if(s_is_digit(*token))
            {
                tk_prec[prec_count ++] = *token;
                xs = XS_PREC; //继续精度扫描
                xo = XO_CONTINUE;
            }else
            {
                xs = XS_SIZE; //过渡到整形指示扫描
                xo = XO_PAUSE;
            }
            break;
        case XS_SIZE:
            if(s_is_size(*token))
            {
                xf_size = *token;
                xs = XS_TYPE; //过渡到格式符扫描
                xo = XO_CONTINUE;
            }else
            {
                xs = XS_TYPE; //过渡到格式符扫描
                xo = XO_PAUSE;
            }
            break;
        case XS_TYPE:
            if(s_is_type(*token))
            {
                xf_type = *token;
                xs = XS_PROC; //过渡到处理格式
                xo = XO_CONTINUE;
            }else
            {
                xs = XS_PROC; //无效格式符，则过渡到前缀串处理
                xo = XO_CONTINUE;
            }
            break;
        case XS_PROC:
            if(xf_type) //处理格式串
            {
                tk_width[width_count] = '\0';
                xf_width = atoi(tk_width);
                tk_prec[prec_count] = '\0';
                xf_prec = atoi(tk_prec);
                if(!xf_flag)
                    xf_flag = ' ';
                if(xf_prec && xf_prec > MAX_PREC) //限制最大精度为6
                    xf_prec = MAX_PREC;
                //处理这个单元的格式串
                total += _tk_sprintf((buf)? (buf + total) : NULL,xf_flag,xf_width,xf_prec,xf_size,xf_type,&arg);

                if(*token == '\0')
                    xs = XS_TERM;
                else
                    xs = XS_SKIP;
                xo = XO_PAUSE;
            }else //处理前缀串
            {
                if(buf)
                {
                    memcpy((void*)(buf + total),(void*)(token - tk_count),tk_count * sizeof(char));
                    buf[total + tk_count] = '\0';
                }
                total += tk_count;

                if(*token == '\0')
                    xs = XS_TERM;
                else
                    xs = XS_SKIP;
                xo = XO_PAUSE;
            }
            xf_flag = 0;
            xf_width = 0;
            xf_prec = 0;
            xf_size = 0;
            xf_type = 0;
            width_count = prec_count = tk_count = 0;

            break;
        }

        if(xo == XO_CONTINUE)
        {
            token ++;
            tk_count ++;
        }
    }

    va_end(arg);

    return total;
}


int _tk_sprintf(char* buf,char flag,int width,int prec,char size,char type,va_list* parg)
{
    wchar_t wch;
    char tmp[NUM_LEN + 1] = {0};
    int len,pos;
    char sign;
    short s;
    int i;
    unsigned short us;
    unsigned int ui,xi;
    double dbl;
    char* sz;
    wchar_t* wsz;

    switch(type)
    {
    case 'c':
        if(buf)
        {
            buf[0] = va_arg(*parg,char);
            buf[1] = '\0';
        }
        return 1;
    case 'C':
        wch = va_arg(*parg,wchar_t);
        len = WideCharToMultiByte(CP_ACP,0,&wch,1,NULL,0,NULL,NULL);
        if(buf)
        {
            WideCharToMultiByte(CP_ACP,0,&wch,1,buf,len,NULL,NULL);
            buf[len] = '\0';
        }
        return len;
    case 'd':
        len = 0;
        sign = 0;
        pos = 0;
        if(size == 'h')
        {
            s = va_arg(*parg,short);
            if(s < 0)
            {
                sign = '-';
                s = 0 - s;
            }
            
            while(s)
            {
                tmp[len ++] = s % 10 + 48;
                s /= 10;
            }
        }else
        {
            i = va_arg(*parg,int);
            if(i < 0)
            {
                sign = '-';
                i = 0 - i;
            }

            while(i)
            {
                tmp[len ++] = i % 10 + 48;
                i /= 10;
            }
        }
        if(sign)
        {
            if(buf)
                buf[pos] = sign;
            pos ++;
            width --;
        }
        width -= len;
        while(width > 0)
        {
            if(buf)
                buf[pos] = '0';
            pos ++;
            width --;
        }
        while(len--)
        {
            if(buf)
                buf[pos] = tmp[len];
            pos ++;
        }
        if(buf)
            buf[pos] = '\0';
        return pos;
    case 'u':
        len = 0;
        sign = 0;
        pos = 0;
        if(size == 'h')
        {
            us = va_arg(*parg,unsigned short);
            while(us)
            {
                tmp[len ++] = us % 10 + 48;
                us /= 10;
            }
        }else
        {
            ui = va_arg(*parg,unsigned int);
            while(ui)
            {
                tmp[len ++] = ui % 10 + 48;
                ui /= 10;
            }
        }
        width -= len;
        while(width > 0)
        {
            if(buf)
                buf[pos] = '0';
            pos ++;
            width --;
        }
        while(len--)
        {
            if(buf)
                buf[pos] = tmp[len];
            pos ++;
        }
        if(buf)
            buf[pos] = '\0';
        return pos;
    case 'x':
    case 'X':
        len = 0;
        sign = 0;
        pos = 0;

        if(buf)
        {
            buf[0] = '0';
            buf[1] = type;
        }
        pos += 2;

        ui = va_arg(*parg,unsigned int);
        while(ui)
        {
            us = ui % 16;
            if(type == 'x')
                tmp[len ++] = (us < 9)? (us + 48) : (us + 87);
            else
                tmp[len ++] = (us < 9)? (us + 48) : (us + 55);
            ui /= 16;
        }

        width -= len;
        while(width > 0)
        {
            if(buf)
                buf[pos] = '0';
            pos ++;
            width --;
        }
        while(len--)
        {
            if(buf)
                buf[pos] = tmp[len];
            pos ++;
        }
        if(buf)
            buf[pos] = '\0';
        return pos;
    case 'f':
        len = 0;
        sign = 0;
        pos = 0;

        dbl = va_arg(*parg,double);
        if(dbl < 0)
        {
            sign = '-';
            dbl = 0 - dbl;
        }

        xi = (int)dbl;

        dbl -= (double)xi;
        if(prec)
            s = (short)prec;
        else
            s = MAX_PREC;
        while(s--)
            dbl *= 10.0;

        ui = (int)floor(dbl + 0.5);

        if(!prec)
        {
            while(!(ui % 10))
                ui /= 10;
        }

        while(ui)
        {
            tmp[len ++] = ui % 10 + 48;
            ui /= 10;
        }
        if(len)
            tmp[len ++] = '.';

        while(xi)
        {
            tmp[len ++] = xi % 10 + 48;
            xi /= 10;
            width --;
        }

        if(sign)
        {
            if(buf)
                buf[pos] = sign;
            pos ++;
            width --;
        }

        while(width > 0)
        {
            if(buf)
                buf[pos] = '0';
            pos ++;
            width --;
        }

        while(len--)
        {
            if(buf)
                buf[pos] = tmp[len];
            pos ++;
        }
        if(buf)
            buf[pos] = '\0';
        return pos;
    case 's':
        len = 0;
        sign = 0;
        pos = 0;

        sz = va_arg(*parg,char*);
        if(!sz)
        {
            if(buf)
                buf[pos] = '\0';
            return pos;
        }
       
        len = strlen(sz);
        width -= len;
        while(width > 0)
        {
            if(buf)
                buf[pos] = flag;
            pos ++;
            width --;
        }

        if(buf)
            memcpy((void*)(buf + pos),(void*)sz,len * sizeof(char));
        pos += len;
        if(buf)
            buf[pos] = '\0';
        return pos;
    case 'S':
        len = 0;
        sign = 0;
        pos = 0;

        wsz = va_arg(*parg,wchar_t*);
        if(!wsz)
        {
            if(buf)
                buf[pos] = '\0';
            return pos;
        }

        ui = wcslen(wsz);
        len = WideCharToMultiByte(CP_ACP,0,wsz,ui,NULL,0,NULL,NULL);
        width -= len;
        while(width > 0)
        {
            if(buf)
                buf[pos] = flag;
            pos ++;
            width --;
        }
       
        if(buf)
            WideCharToMultiByte(CP_ACP,0,wsz,ui,buf + pos,len,NULL,NULL);
        pos += len;
        if(buf)
            buf[pos] = '\0';
        return pos;
    }
    return 0;
}

这样：
int len = xspritf(NULL,"这次要分配%d个字节,18)可以返回结果串的精确长
xsprintf(buf,"a=%s",NULL)不会格式成a=(null)
xsprintf(buf,"a=%f",8.0/9.0)不会返回长长的尾巴了
xsprintf(buf,"%svs%S","俄罗斯"，L"荷兰")可以处理MBCS和UNICODE
少了些麻烦
不过没有支持[e,E,f,g,]的格式符，抱歉了
UICODE版的xwprintf道理也是一样的，就不贴出来了

 

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/10321586/viewspace-364629/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/10321586/viewspace-364629/

cssie6512
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
stm32串口重写及sprintf函数
qq_55695208的博客
05-17 3666
sprintf函数 字符串格式化函数 sprintf主要功能把格式化的数据写在某个字符串中，使用sprintf时经常出问题，需要格外注意。 sprintf 是个变参函数 ，该函数包含在stdio.h的头文件中，使用时需导入这个头文件。 int sprintf( char *buffer, const char *format [, argument] ... ); 除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：格式化字符串上。 sprintf 最常见的应用之一莫
sprintf 函数详细解释
weixin_33798152的博客
05-25 574
sprintf() 格式化输出函数 功能：　函数sprintf()用来作格式化的输出。 用法：　此函数调用方式为int sprintf(char *string,char *format,arg_list); 说明：　函数sprintf()的用法和printf()函数一样，只是sprintf()函数给出第一个参数string(一般为字符数组），然后再调 用 outtextxy()函数将...
linux free 空指针,printf/sprintf/NULL
weixin_36009111的博客
05-25 773
最近从windows到linux 迁移代码，遇到了一个sprintf参数空指针段错误。很疑惑，按说项目这么久不该出现段错误。1.代码原代码(用到msxml)sprintf(pItemData.szNodeText,"%s",(const char*)nodeptr->Gettext());移植后的代码(用到libxml2)xmlCharTemp = xmlNodeGetContent(xml...
glibc sprintf源码梳理（上）
舍本逐末
03-04 1722
尝试阅读sprint源码 glibc 版本2.11 0. sprintf和snprintf sprintf和snprintf的是字符串格式化方法，可将格式化数据写入字符串中。 snprintf规定了写入字符串的最大长度，避免字符串长度溢出 sprintf和snprintf方法定义在libio/stdio.h中，其声明和方法参数说明如下： /* __s : 字符数组指针，存储拼接后的字符串 __format: 字符串，规定了字符串格式 ... : 可变参数，填充format中的值
sprintf和snprintf基本用法，与越界问题
Wang_XB_3434的博客
03-22 1116
嗨喽，大家好，我是程序猿老王，程序猿老王就是我。 今天我给大家分享一下，我在使用sprintf函数遇到的坑。
编写myprintf
qq_36534818的博客
12-31 939
 #include #include #include void printInt(int data) {  int q=data/10;  if(q!=0)  {   printInt(q);  }  putchar(data%10+'0'); } int myprintf(const char *format,...) {  assert(format);
sprintf函数的解释
06-12
sprintf 函数详解 sprintf 函数是一种格式化输出函数，经常用于嵌入式开发中输出问题的解决方案。该函数的用法与 printf 函数相似，但其输出结果是将格式化后的字符串保存到指定的字符数组中，而不是直接输出到屏幕...
binprotect:利用二进制重写技术的追溯二进制保护
05-26
BinProtect加强了对不安全的标准C库函数（例如strcpy（），gets（），sprintf（）等的调用）。 为此，对二进制文件进行转换的方式是，对静态或动态链接的标准C库的调用都将被拦截，并由强化的包装程序实现代替...
用C++ Builder改写的FMX炫酷界面及仿QQ登陆界面Demo(CBXE8源码)
09-15
在FireMonkey群里看到2位网友上传的界面Demo,下载学习了一下，发现FMX做的界面效果不错，在此特别感谢两位提供源码的网友，不过都是用delphi写的，学习后就仿照着尝试用CB重写了一下，由于语法有些不同，中间遇到...
basic study.docx
04-04
13. 成员函数重写、重载和隐藏：重写发生在派生类中对基类的虚函数进行重新定义，重载在同一类中通过参数列表不同定义多个同名函数，隐藏是指派生类中定义了与基类同名但参数不同的函数，使得基类的同名函数在派生类...
精简版sprintf
07-11
嵌入式开发时经常要用到字符串转换函数sprintf，但标准C函数库非常占内存，重写更高效更精简的sprintf函数，比C标准库里自带的sprintf更高效，适用于嵌入式或上位软件开发。
sprintf函数
07-27
sprintf函数的详细介绍，里面详细介绍了sprintf 的基本用法，非常适合初学者。
嵌入式面试技术问题汇总_嵌入式-常用知识&面试题库_大厂面试真题.docx
08-07
嵌入式面试技术问题汇总 本资源包含了嵌入式面试中常见的技术问题，涵盖了计算机网络、操作系统、数据结构、编程语言、嵌入式系统等...* 重写：重写是指子类对父类函数的重写。 * 重定义：重定义是指函数的重新定义。
51单片机使用sprintf和printf
热门推荐
Lim的博客
06-06 5万+
srpintf()函数的功能非常强大：效率比一些字符串操作函数要高；而且更具灵活性；可以将想要的结果输出到指定的字符串中，也可作为缓冲区，而printf只能输出到命令行上~ 头文件：stdio.h 函数功能：格式化字符串，将格式化的数据写入字符串中。 函数原型：int sprintf(char *buffer, const char *format, [argument]…) 函数返回值：buffer指向的字符串的长度； 注意：这里一定要强转为int类型 原因：可能是8位的系统和32位的系统存储方式不一样，
当sprintf遇到string
gongzhu110的专栏
12-29 3451
       一直都知道sprintf使用string参数时一定要用.c_str()转换为char*之后才行，否则就会出现“(NULL)”。一次疏忽，在sprintf中发现“(NULL)”，但是此参数是一个char*，无论如何找不到char*成为“(NULL)”的原因。后对sprintf的每次参数详细检查时才发现这个char*前一个参数是string，忘了转成char*，它自己没有变成“(NULL...
c++可变参的函数，printf的重写(转)
liziyun537的专栏
03-04 8879
里面有一些错误，悠着点看1.va_start() va_end()函数 应用（http://www.daydreaming.com.cn/article/2007-5-31/1838-1.htm） 1:当无法列出传递函数 的所有实参的类型和数目时,可用省略号指定参数表void foo(...); void foo(parm_list,...);2:函数 参数的传递原理函数 参数是以数据结构:栈的形式存取,从右至左入栈.eg: #include void fun(int a, ...)  {
QT的sprintf重写；qt下内容按界面的缩放而缩放（不改变字体大小）
ch593030323的专栏
03-25 952
QT的sprintf重写 QString MainWindow::sprintf(const char *cformat, ...) { va_list ap; va_start(ap, cformat); return QString::vasprintf(cformat, ap); } 打印： qDebug() << sprintf("%d", 12)...
sprinf函数
weixin_43763889的博客
12-15 638
头文件：#include <stdio.h> sprintf()函数用于将格式化的数据写入字符串，其原型为： int sprintf(char *str, char * format [, argument, …]); 【参数】str为要写入的字符串；format为格式化字符串，与printf()函数相同；argument为变量。 除了前两个参数类型固定外，后面可以接任意多个参数。而它...
重写printf
weixin_37663721的博客
09-17 3233
重写printf 文章目录重写printf前言一、可变参函数二、占位符和可变参共同实现printf1.代码实现2.读入数据总结二级标题三级标题四级标题五级标题六级标题 前言   在使用stm32时，有时候需要用到两个printf，但是通过重定向，只能把printf重定向到一个串口上。因此打算重写一个printf函数。 一、可变参函数   要实现重写printf函数就首先需要学习可变参函数。可变参函数这个是怎么实现，首先我们就要先理解一点，参数是如何传递给函数的。众所周知，函数的数据是存放于栈中的，那么给一
sprintfsprintf
最新发布
03-31
sprintf是一个C语言中的函数，用于将格式化的数据写入字符串中。它的原型如下： ```c int sprintf(char *str, const char *format, ...); ``` 其中，str是一个指向字符数组的指针，用于存储格式化后的字符串；...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值