Namespaces
Variants

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

    来自 zh.cppreference.net
     
    C++
     
    输入/输出库
     
    C 风格 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 - 指向指定如何读取输入的空终止字符串的指针
    ... - 接收参数

    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 个字符的空间）。
    [set ]

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

    • 如果集合的第一个字符是 ^，则匹配所有不在集合中的字符。
    • 如果集合以 ] 或 ^] 开头，则 ] 字符也会包含在集合中。
    • 扫描集中非初始位置处的字符 - 是否表示范围（如 [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 bug 1765。

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

    返回值

    成功赋值的接收参数的数量（如果在赋值第一个接收参数之前发生匹配失败，则可能为 0），或者如果在赋值第一个接收参数之前发生输入失败，则为 EOF。

    复杂度

    无保证。值得注意的是，某些 std::sscanf 的实现是 O(N)，其中 N = std::strlen(buffer) [1]。对于高性能的字符串解析，请参见 std::from_chars。

    注解

    因为大多数转换说明符首先会消耗所有连续空白，所以代码如 

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

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

    不消耗前导空白的转换说明符（例如 %c）可以通过在格式字符串中使用空白字符来使其消耗：

    std::scanf("%d", &a);
std::scanf(" %c", &c); // ignore the endline after %d, then read a char

    注意某些 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ß水";
    // parse as follows:
    // %d: an integer 
    // %f: a floating-point value
    // %9s: a string of at most 9 non-whitespace characters
    // %2d: two-digit integer (digits 5 and 6)
    // %f: a floating-point value (digits 7, 8, 9)
    // %*d an integer which isn't stored anywhere
    // ' ': all consecutive whitespace
    // %3[0-9]: a string of at most 3 digits (digits 5 and 6)
    // %2lc: two wide characters, using multibyte to wide conversion
    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 << "Converted " << ret << " fields:\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';
}

    输出： 

    Converted 7 fields:
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