C语言字符串处理函数 sprintf() 和 sscanf() 的使用

1、sprintf()

根据参数 format 字符串来转换并格式化数据，然后将结果输出到 str 指定的空间中， 直到出现字符串结束符 ‘\0’ 为止。代码如下，

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
/*
int sprintf(char *_CRT_SECURE_NO_WARNINGS, const char *format, ...);
参数
str：字符串首地址
format：字符串格式，用法和 printf()一样
返回值
成功：实际格式化的字符个数
失败：-1
*/
    //1. 格式化字符串
    char buf[1024] = { 0 };
    sprintf(buf, "你好,%s,", "cjavapy");
    printf("buf:%s\n",buf);

    memset(buf, 0, 1024);
    sprintf(buf, "我今年%d", 5);
    printf("buf:%s\n", buf);

    //2. 拼接字符串
    memset(buf, 0, 1024);
    char str1[] = "hello";
    char str2[] = "world";
    int len = sprintf(buf,"%s %s",str1,str2);
    printf("buf:%s len:%d\n", buf,len);

    //3. 数字转字符串
    memset(buf, 0, 1024);
    int num = 100;
    int f1 = 100.111;
    sprintf(buf, "%d", num);

    memset(buf, 0, 1024);
    int f2 = 100.111;
    sprintf(buf, "%f", f2);
    printf("buf:%s\n", buf);

    //4. 设置对齐与输出格式
    //设置宽度 右对齐
    memset(buf, 0, 1024);
    sprintf(buf, "%8d", num);
    printf("buf:%s\n", buf);
    //设置宽度 左对齐
    memset(buf, 0, 1024);
    sprintf(buf, "%-8d", num);
    printf("buf:%s\n", buf);
    //转成16进制字符串 小写
    memset(buf, 0, 1024);
    sprintf(buf, "0x%x", num);
    printf("buf:%s\n", buf);

    //转成8进制字符串
    memset(buf, 0, 1024);
    sprintf(buf, "0%o", num);
    printf("buf:%s\n", buf);

    return 0;
}

2、sscanf()

从 str 指定的字符串读取数据，并根据参数 format 字符串来转换并格式化数据。代码如下，

#include <stdio.h>
#include <string.h>

int main ()
{
/*
int sscanf(const char *str, const char *format, ...);
参数
str：指定的字符串首地址
format：字符串格式，用法和 scanf()一样
返回值
成功：参数数目，成功转换的值的个数
失败： - 1
*/
 /*
    //* 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)*/
    const char *p1 = "abcd123";
    char buf1[32] = { 0 };
    sscanf(p1, "%*[a-z]%s", buf1); //跳过字母
    printf("-- buf1[%s]--\n", buf1);

    //[a|b|c]表示a,b,c中选一
    const char *p2 = "3b";
    char buf2_1[32] = { 0 };
    char buf2_2[32] = { 0 };
    sscanf(p2, "%[1|2|3]%c", buf2_1, buf2_2);  //或运算符使用
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf2_1, buf2_2);
    
    //[d],表示可以有d也可以没有d。
    const char *p3 = "b";
    char buf3_1[32] = { 0 };
    char buf3_2[32] = { 0 };
    sscanf(p3, "%[3]%c", buf3_1, buf3_2);  //无法提取任何数据
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf3_1, buf3_2);
    
    //[d],表示可以有d也可以没有d。
    const char *p4 = "b";
    char buf4_1[32] = { 0 };
    char buf4_2[32] = { 0 };
    sscanf(p4, "%c%[3]", buf4_1, buf4_2);  //可以正常提取b
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf4_1, buf4_2);
    //结论:sscanf提取字符串必须知道字符串的具体格式，使用上不如正则灵活
    
    //width表示读取宽度。
    const char *p5 = "abcdef123";
    char buf5_1[32] = { 0 };
    char buf5_2[32] = { 0 };
    sscanf(p5, "%3s%s", buf5_1, buf5_2);  //%3s 表示提取3个字符的字符串
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf5_1, buf5_2);
    
    // h|I|I64 是配合%d提取整数使用 L 是配合%f提取浮点数使用，h表示short类型数据，I表示int类型数据，I64表示长整型数据
    const char *p6 = "123578abc";
    int buf6_1;
    char buf6_2[32] = { 0 };
    sscanf(p6, "%Id%s", &buf6_1, buf6_2);
    printf("-- buf1[%d]--buf2_2[%s]---\n", buf6_1, buf6_2);
    
    //控制字符
    //  %c 一个单一的字符
    //    %d 一个十进制整数
    //    %i 一个整数
    //    %e, %f, %g 一个浮点数
    //    %o 一个八进制数
    //    %s 一个字符串
    //    %x 一个十六进制数
    //    %p 一个指针
    //    %n 一个等于读取字符数量的整数
    //    %u 一个无符号整数
    //    %[] 一个字符集
    //    %% 一个精度符号
    const char *p7 = "123578abc";
    char ch7 = 0;
    char buf7_2[32] = { 0 };
    sscanf(p7, "%c%s", &ch7, buf7_2);
    printf("-- buf1[%c]--buf2_2[%s]---\n", ch7, buf7_2);
    
    //sscanf函数遇到空格停止读取字符串,所有需要特地注明空格
    const char *p8 = "123   578a  bc";
    char buf8_1[32] = { 0 };
    char buf8_2[32] = { 0 };
    sscanf(p8, "%s%*[ ]%s", buf8_1,buf8_2); //格式化里有空格，可以提取
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf8_1, buf8_2);
    
    //^ 取到指定字符为止的字符串
    const char *p9 = "123abc";
    char buf9_1[32] = { 0 };
    char buf9_2[32] = { 0 };
    sscanf(p9, "%[^2]%s", buf9_1,buf9_2);
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf9_1, buf9_2);
    
    //截取到指定字符串 "3ab"
    const char *p10 = "12-3ab-c";
    char buf10_1[32] = { 0 };
    char buf10_2[32] = { 0 };
    sscanf(p10, "%*[^-]-%[^-]%s", buf10_1, buf10_2); 
    printf("-- buf1[%s]--buf2_2[%s]---\n", buf10_1, buf10_2);
   return(0);
}