Namespaces
Variants

    std:: scanf, std:: fscanf, std:: sscanf

    From zh.cppreference.net
    < cpp ‎ | io ‎ | c
    C++
    Input/output library
    C-style I/O
    定义于头文件 <cstdio>
    int scanf ( const char * format, ... ) ;
    		(1)
    int fscanf ( std:: FILE * stream, const char * format, ... ) ;
    		(2)
    int sscanf ( const char * buffer, const char * format, ... ) ;
    		(3)

    从多种来源读取数据，根据 format 解释数据，并将结果存储到指定位置。

    1) 从 stdin 读取数据。
    2) 从文件流 stream 中读取数据。
    3) 从以空字符结尾的字符串 buffer 中读取数据。

    内容

    参数

    stream - 要读取的输入文件流
    buffer - 指向要读取的以空字符结尾的字符串的指针
    format - 指向指定如何读取输入的以空字符结尾的字符串的指针
    ... - 接收参数

    格式字符串由以下部分组成：

    • 非空白多字节字符（% 除外）：格式字符串中的每个此类字符精确消耗输入流中的一个相同字符，如果流中的下一个字符不相等，则导致函数失败。
    • 空白字符：格式字符串中的任何单个空白字符消耗输入中所有连续的空白字符（如同通过循环调用 std::isspace 确定）。注意，格式字符串中的 "\n"、" "、"\t\t" 或其他空白字符之间没有区别。
    • 转换说明。每个转换说明具有以下格式：
    • 引导 % 字符。
    • (可选) 赋值抑制字符 *。如果存在此选项，函数不将转换结果赋给任何接收参数。
    • (可选) 指定 最大字段宽度的整数（大于零），即函数在执行当前转换说明指定的转换时允许消耗的最大字符数。注意，如果没有提供宽度，%s 和 %[ 可能导致缓冲区溢出。
    • (可选) 长度修饰符，指定接收参数的大小，即实际的目标类型。这会影响转换精度和溢出规则。默认目标类型因转换类型而异（见下表）。
    • 转换格式说明符。

    以下是可用的格式说明符：

    转换
    说明符     		解释 期望
    参数类型
    长度修饰符→ hh h 无 l ll j z t L
    自 C++11 起可用→ 是 是 是 是 是
    %
    匹配字面量 %。
    		N/A N/A N/A N/A N/A N/A N/A N/A N/A
    c

    匹配一个字符或一系列字符。

    • 如果使用了宽度说明符，则精确匹配 width 个字符（参数必须是指向具有足够空间的数组的指针）。
    • 与 %s 和  %[ 不同，不向数组追加空字符。
    		N/A N/A
    char*
    wchar_t*
    		 N/A N/A N/A N/A N/A
    s

    匹配非空白字符序列（字符串）。

    • 如果使用了宽度说明符，则最多匹配 width 个字符或直到第一个空白字符，以先到者为准。
    • 总是存储一个空字符以及匹配的字符（因此参数数组必须至少能容纳 width+1 个字符）。
    [集合 ]

    匹配来自集合字符的非空序列。

    • 如果集合的第一个字符是 ^，则匹配所有不在集合中的字符。
    • 如果集合以 ] 或 ^] 开头，则 ] 字符也包含在集合中。
    • 由实现定义扫描集中非初始位置的 - 字符是否可表示范围，如 [0-9] 中所示。
    • 如果使用了宽度说明符，则只匹配最多 width。
    • 总是存储一个空字符以及匹配的字符（因此参数数组必须至少能容纳 width+1 个字符）。
    d

    匹配十进制整数。

    • 数字的格式与 std::strtol 预期相同，其中 10 参数值为 base。
    signed char* 或 unsigned char*
    signed short* 或 unsigned short*
    signed int* 或 unsigned int*
    signed long* 或 unsigned long*
    signed long long* 或 unsigned long long*
    std::intmax_t* 或 std::uintmax_t*
    std::size_t*
    std::ptrdiff_t*
    		 N/A
    b (C++26)

    匹配无符号二进制整数。

    • 数字的格式与 std::strtoul 预期相同，其中 2 参数值为 base。
    i

    匹配整数。

    • 数字的格式与 std::strtol 预期相同，其中 0 参数值为 base（基数由解析的第一个字符确定）。
    u

    匹配无符号十进制整数。

    • 数字的格式与 std::strtoul 预期相同，其中 10 参数值为 base。
    o

    匹配无符号八进制整数。

    • 数字的格式与 std::strtoul 预期相同，其中 8 参数值为 base。
    x
    X

    匹配无符号十六进制整数。

    • 数字的格式与 std::strtoul 预期相同，其中 16 参数值为 base。
    n

    返回到目前为止读取的字符数。

    • 不消耗输入。不增加赋值计数。
    • 如果说明符定义了赋值抑制操作符，行为未定义。
    a (C++11)
    A (C++11)
    e
    E
    f
    F (C++11)
    g
    G

    匹配浮点数。

    • 数字的格式与 std::strtof 预期相同。
    		N/A N/A
    float*
    double*
    		 N/A N/A N/A N/A
    long double*
    p

    匹配实现定义的字符序列，定义指针。

    • printf 系列函数应使用 %p 格式说明符产生相同序列。
    		N/A N/A
    void**
    		 N/A N/A N/A N/A N/A N/A
    注意

    对于除 n 外的每个转换说明符，消耗不超过任何指定字段宽度且要么正是转换说明符所期望的序列，要么是它所期望序列的前缀的最长输入字符序列。此消耗序列之后的第一个字符（如果有）保持未读。如果消耗序列长度为零或消耗序列无法按上述转换，则发生匹配失败，除非文件结束、编码错误或读取错误阻止了流输入，此时为输入失败。

    除 % 说明符外，输入项（或对于 %n，输入字符数）首先转换为适用于转换说明符的类型。除非使用 * 抑制了赋值，转换结果写入下一个尚未写入的参数所指向的对象。如果此对象没有合适的类型，或者转换结果无法在对象中表示，则行为未定义。

    除 [、c 和 n 外的所有转换说明符在尝试解析输入前消耗并丢弃所有前导空白字符（如同通过调用 std::isspace 确定）。这些消耗的字符不计入指定的最大字段宽度。

    转换说明符 lc、ls 和 l[ 执行多字节到宽字符转换，如同在转换第一个字符前调用 std::mbrtowc，并在之前初始化为零的 std::mbstate_t 对象。

    转换说明符 s 和 [ 总是存储空终止符以及匹配的字符。目标数组的大小必须至少比指定字段宽度大一。使用 %s 或 %[ 而不指定目标数组大小与 std::gets 一样不安全。

    定宽整数类型（std::int8_t 等）的正确转换说明在头文件 <cinttypes> 中定义（尽管 SCNdMAX、SCNuMAX 等与 %jd、%ju 等同义）。

    每个转换说明符的操作后有一个序列点；这允许将多个字段存储到同一个“接收”变量中。

    当解析以指数结尾但无数字的不完整浮点值时，例如使用转换说明符 "100er" 解析 %f，序列 "100e"（可能有效浮点数的最长前缀）被消耗，导致匹配错误（消耗的序列无法转换为浮点数），剩余 "r"。一些现有实现不遵循此规则并回退仅消耗 "100"，留下 "er"，例如 glibc 错误 1765。

    如果转换说明无效，行为未定义。

    返回值

    成功接收并赋值的参数数量（若在首个接收参数被赋值前发生匹配失败，则该值可能为零），或 EOF 若在首个接收参数被赋值前发生输入失败。

    复杂度

    不保证性能。特别需要注意的是，某些 std::sscanf 的实现是 O(N) 的，其中 N = std:: strlen ( buffer ) [1] 。如需高性能字符串解析，请参阅 std::from_chars 。

    注释

    由于大多数转换说明符首先会消耗所有连续的空白字符，因此诸如 

    std::scanf("%d", &a);
std::scanf("%d", &b);

    将读取在不同行输入的两个整数（第二个 % d 会消耗第一个输入遗留的换行符）或在同一行输入、以空格或制表符分隔的两个整数（第二个 % d 会消耗空格或制表符）。

    The conversion specifiers that do not consume leading whitespace, such as % c , can be made to do so by using a whitespace character in the format string: 
    std::scanf("%d", &a);
std::scanf(" %c", &c); // 忽略 %d 后的换行符，然后读取一个字符

    请注意，某些 std::sscanf 的实现会调用 std::strlen ，这导致其运行时间与整个字符串的长度成线性关系。这意味着如果在循环中调用 std::sscanf 来重复解析字符串前端的值，您的代码可能会以二次方时间运行（ 示例 ）。

    示例

    运行此代码 
    #include <clocale>
#include <cstdio>
#include <iostream>
int main()
{
    int i, j;
    float x, y;
    char str1[10], str2[4];
    wchar_t warr[2];
    std::setlocale(LC_ALL, "en_US.utf8");
    char input[] = "25 54.32E-1 Thompson 56789 0123 56ß水";
    // 解析方式如下：
    // %d: 整数
    // %f: 浮点数值
    // %9s: 最多9个非空白字符的字符串
    // %2d: 两位整数（数字5和6）
    // %f: 浮点数值（数字7、8、9）
    // %*d: 不存储在任何位置的整数
    // ' ': 所有连续空白字符
    // %3[0-9]: 最多3位数字的字符串（数字5和6）
    // %2lc: 两个宽字符，使用多字节到宽字符转换
    const int ret = std::sscanf(input, "%d%f%9s%2d%f%*d %3[0-9]%2lc",
                                &i, &x, str1, &j, &y, str2, warr);
    std::cout << "转换了 " << ret << " 个字段：\n"
                 "i = " << i << "\n"
                 "x = " << x << "\n"
                 "str1 = " << str1 << "\n"
                 "j = " << j << "\n"
                 "y = " << y << "\n"
                 "str2 = " << str2 << std::hex << "\n"
                 "warr[0] = U+" << (int)warr[0] << "\n"
                 "warr[1] = U+" << (int)warr[1] << '\n';
}

    输出： 

    转换了 7 个字段：
i = 25
x = 5.432
str1 = Thompson
j = 56
y = 789
str2 = 56
warr[0] = U+df
warr[1] = U+6c34

    另请参阅

    (C++11) (C++11) (C++11)
    		从 stdin 、文件流或缓冲区读取格式化输入
    使用可变参数列表
    （函数）
    		从文件流获取字符串
    （函数）
    (C++11)
    		将格式化输出打印到 stdout 、文件流或缓冲区
    （函数）
    (C++17)
    		将字符序列转换为整型或浮点型值
    （函数）
    C 文档 关于 scanf 、 fscanf 、 sscanf