效率这一点没注意到。习惯了sprintf，没想到会是这个情况。话说如果自己写变参函数，完成和printf一样的格式化处理，有没有sprintf一样的问题？比如

void formatComStr(unsigned char column, unsigned char page, const char *format, ...) {
    //char buffer[256];
    char temp[12];
    va_list args;
    char *p;
    int num;
    int i;
    char *str;
    int arg_int;
    unsigned int hex_num;
    char hex_chars[] = "0123456789ABCDEF";
    
    // 初始化
    p = buffer;
    buffer[0] = '\0';
    
    va_start(args, format);
    
    while(*format) {
        if(*format == '%') {
            format++;
            switch(*format) {
                case 'd':
                    num = va_arg(args, int);
                    if(num < 0) {
                        *p++ = '-';
                        num = -num;
                    }
                    i = 0;
                    if(num == 0) {
                        temp[i++] = '0';
                    } else {
                        while(num > 0) {
                            temp[i++] = '0' + (num % 10);
                            num /= 10;
                        }
                    }
                    while(i > 0) {
                        *p++ = temp[--i];
                    }
                    break;
                    
                case 's':
                    str = va_arg(args, char*);
                    while(*str) {
                        *p++ = *str++;
                    }
                    break;
                    
                case 'c':
                    arg_int = va_arg(args, int);
                    *p++ = (char)arg_int;
                    break;
                    
                // ========== 新增：十六进制支持 ==========
                case 'x':  // 小写十六进制
                case 'X': { // 大写十六进制
                    hex_num = va_arg(args, unsigned int);
                    
                    // 处理0的特殊情况
                    if(hex_num == 0) {
                        *p++ = '0';
                        break;
                    }
                    
                    // 转换为十六进制字符串
                    i = 0;
                    while(hex_num > 0 && i < 8) {
                        temp[i++] = hex_chars[hex_num & 0x0F];
                        hex_num >>= 4;
                    }
                    
                    // 反转输出
                    while(i > 0) {
                        *p++ = temp[--i];
                    }
                    break;
                }
                
                case '0': {
                    // 检查是否是 %02x 格式
                    format++;
                    if(*format == '2') {
                        format++;
                        if(*format == 'x' || *format == 'X') {
                            hex_num = va_arg(args, unsigned int);
                            // 始终输出2位十六进制
                            temp[0] = hex_chars[(hex_num >> 4) & 0x0F];
                            temp[1] = hex_chars[hex_num & 0x0F];
                            *p++ = temp[0];
                            *p++ = temp[1];
                            break;
                        }
                    }
                    // 如果不是 %02x，回退到默认
                    *p++ = '%';
                    *p++ = '0';
                    *p++ = *format;
                    break;
                }
                
                default:
                    *p++ = '%';
                    *p++ = *format;
                    break;
            }
        } else {
            *p++ = *format;
        }
        format++;
    }
    
    *p = '\0';
    va_end(args);
    
    printf(buffer);
}

这样的

这得啥项目上要把性能优化到这种程度啊？！