1

我正在研究如何scanf工作。

扫描其他类型变量后,char 变量通过getchar()or存储一个 white-space('\n') scanf("%c")。为了防止这种情况,他们应该清除缓冲区。我做到了rewind(stdin)

尽管 stdin 被倒带,但先前的输入值保留在缓冲区中。我可以正常使用以前的值做一些事情。(没有运行时错误)但是如果我再试scanf一次,即使缓冲区中有正常值,scanf 也会扫描一个新值。scanf 如何确定是否应该扫描新值?

我用下面的代码找到了这个机制。

#include <stdio.h>
#define p stdin

int main() {
    int x;
    char ch;

    void* A, * B, * C, * D, * E;

    A = p->_Placeholder;
    printf("A : %p\n", A);//first time, it shows 0000
    scanf_s("%d", &x);

    B = p->_Placeholder;
    printf("B : %p\n", B);//after scanned something, I think it's begin point of buffer which is assigned for this process
    rewind(stdin);//rewind _Placeholder 

    C = p->_Placeholder;
    printf("C : %p\n", C);//it outputs the same value as B - length of x

    D = p->_Placeholder;
    printf("D : %c\n", ((char*)D)[0]);//the previous input value is printed successfully without runtime error. it means buffer is not be cleared by scanf
    scanf_s("%c", &ch, 1);//BUT scanf knows the _Placeholder is not pointing new input value, so it will scan a new value from console. How??

    E = p->_Placeholder;
    printf("E : %p\n", E);
    printf("ch : %c\n", ch);
}
4

3 回答 3

8

你至少有三个误解:

  • “char 变量存储一个空格”
  • rewind(stdin)清除缓冲区
  • _Placeholder告诉你一些关于如何scanf处理空白的有趣的事情

但是,对不起,这些都不是真的。

让我们回顾一下scanf 实际如何处理空格。我们从两个重要的背景信息开始:

  • 换行符 ,\n在大多数方面是一个普通的空白字符。它像任何其他字符一样占用输入缓冲区中的空间。当您按下 Enter 键时,它会到达输入缓冲区。
  • 解析完%-directive 后,scanf始终在输入流上留下未解析的输入。

假设你写

int a, b;
scanf("%d%d", &a, &b);

假设您运行该代码并键入,作为输入

12 34

然后按 Enter 键。怎么了?

首先,输入流 ( stdin) 现在包含六个字符:

"12 34\n"

scanf首先处理%d你给它的两个指令中的第一个。它扫描字符1并将2它们转换为整数 12 并将其存储在变量中a。它在它看到的第一个非数字字符处停止读取,即 和 之间的空格2字符3。输入流现在是

" 34\n"

请注意,空格字符仍在输入流上。

scanfnext 处理第二个%d指令。它不会立即找到数字字符,因为空格字符仍然存在。但这没关系,因为像大多数(但不是全部)scanf格式指令一样,%d它有一个秘密的额外功能:它在读取和转换整数之前自动跳过空白字符。所以第二个%d读取并丢弃空格字符,然后读取字符3并将4它们转换为整数 34,并将其存储在变量中b

现在scanf完成了。输入流只包含换行符:

"\n"

接下来,让我们看一个稍微不同的——尽管我们将看到,实际上非常相似——的例子。假设你写

int x, y;
scanf("%d", &x);
scanf("%d", &y);

假设您运行该代码并键入,作为输入

56
78

(在两行,这意味着您按 Enter 两次)。现在会发生什么?

在这种情况下,输入流最终将包含以下六个字符:

"56\n78\n"

第一个scanf调用有一个%d要处理的指令。它扫描字符5并将6它们转换为整数 56 并将其存储在变量中x。它在它看到的第一个非数字字符处停止读取,即 . 之后的换行符6。输入流现在是

"\n78\n"

请注意,换行符(两个换行符)仍在输入流中。

现在第二个scanf调用运行。它也有一个%d要处理的指令。输入流上的第一个字符不是数字:它是换行符。但这没关系,因为%d知道如何跳过空格。所以它读取并丢弃换行符,然后读取字符7并将8它们转换为整数 78,并将其存储在变量中y

现在第二个scanf完成了。输入流只包含换行符:

"\n"

这可能都是有道理的,可能看起来并不令人惊讶,可能会让你觉得,“好吧,有什么大不了的?” 最重要的是:在这两个示例中,输入都包含最后一个换行符

假设,稍后在您的程序中,您有一些其他输入要读取。我们现在来到一个非常重要的决策点:

  • 如果下一个输入调用是对 的另一个调用scanf,并且如果它涉及(许多)格式说明符之一,该格式说明符具有跳过空格的秘密额外功能,则该格式说明符将跳过换行符,然后执行扫描和转换任何内容的工作输入出现在换行符之后,程序将按您的预期运行。

  • 但是,如果下一个输入调用不是对 的调用scanf,或者如果它scanf是涉及少数几个没有秘密额外权力的输入说明符之一的调用,则不会“跳过”换行符;它将被读取为实际输入。如果下一个输入调用是getchar,它将读取并返回换行符。如果下一个输入调用是fgets,它将读取并返回一个空行。如果下一个输入调用scanf带有%c指令,它将读取并返回换行符。如果下一个输入调用scanf带有%[^\n]指令,它将读取一个空行。(实际上在这种情况下什么%[^\n]都不会读,因为它离开了\n仍在输入中。)

在最后一种情况下,“额外的”空格会导致问题。在最后一种情况下,您发现自己需要显式“刷新”或丢弃额外的空格。

在没有陷入所有血腥细节的情况下,事实证明,刷新或丢弃留下的额外空白scanf是一个非常顽固的问题。你不能通过调用便携地做到这一点fflush。你不能通过调用便携地做到这一点rewind。如果你关心正确的、可移植的代码,你基本上有三个选择:

  1. 编写您自己的代码以显式读取和丢弃“额外”字符(通常,直到并包括下一个换行符)。
  2. 不要试图混合scanf和其他呼叫。不要打电话scanf,然后再尝试打电话getcharor fgets。如果您调用scanf,然后稍后使用缺少“秘密额外功能”scanf的指令之一(例如"%c")调用,请在格式说明符之前插入一个额外的空格以导致跳过空格。(也就是说,使用" %c"而不是"%c"。)
  3. 根本不要使用scanf-用or来完成所有输入。fgetsgetchar

另请参阅我可以使用什么来进行输入转换而不是 scanf?


附录:scanf对空白的处理通常看起来令人费解。如果上述解释还不够,那么查看一些详细说明scanf内部工作原理的实际 C 代码可能会有所帮助。(我要展示的代码显然不是您系统实现背后的确切代码,但它会是相似的。)

scanf需要处理%d指令时,您可能会想象它会做这样的事情。(预先警告:我要向您展示的第一段代码是不完整的。我需要尝试三次才能正确。)

c = getchar();
if(isdigit(c)) {
    int intval;
    intval = c - '0';
    while(isdigit(c = getchar())) {
        intval = 10 * intval + (c - '0');
    }

    *next_pointer_arg = intval;
    n_vals_converted++;
} else {
    /* saw no digit; processing has failed */
    return n_vals_converted;
}

让我们确保我们了解这里发生的一切。我们被告知要处理%d指令。我们通过调用从输入中读取一个字符getchar()。如果该字符是数字,则它可能是构成整数的几个数字中的第一个。我们读取字符,只要它们是数字,我们就将它们添加到整数值intval,我们正在收集。转换包括减去常量'0',将 ASCII 字符代码转换为数字值,然后连续乘以 10。一旦我们看到一个不是数字的字符,我们就完成了。我们将转换后的值存储到调用者传递给我们的指针中(这里示意性地但大致由指针值表示next_pointer_arg),我们将一个变量加到n_vals_converted记录我们已经成功扫描和转换了多少个值,最终将是scanf' 的返回值。

另一方面,如果我们甚至没有看到一个数字字符,我们就失败了:我们立即返回,我们的返回值是到目前为止我们成功扫描和转换的值的数量(很可能是 0 )。

但实际上这里有一个微妙的错误。假设输入流包含

"123x"

此代码将成功扫描数字12和并将其转换3为整数 123,并将此值存储到*next_pointer_arg. 但是,它将读取字符,并且在循环x调用失败后,该字符将被有效地丢弃:它不再在输入流上。isdigitwhile(isdigit(c = getchar()))x

的规范scanf说它应该这样做。的规范scanf说未解析的字符应该留在输入流中。如果用户实际上传递了格式说明符"%dx",这意味着在读取和解析整数之后,x输入流中需要一个文字,并且scanf必须显式读取并匹配该字符。x所以它在解析%d指令的过程中不会意外读取和丢弃。

所以我们需要%d稍微修改一下我们假设的代码。每当我们读取一个结果不是整数的字符时,我们必须将其放回输入流中,以供其他人稍后读取。实际上有一个函数<stdio.h>可以做到这一点,与 . 有点相反getc,称为ungetc. 这是代码的修改版本:

c = getchar();
if(isdigit(c)) {
    int intval;
    intval = c - '0';
    while(isdigit(c = getchar())) {
        intval = 10 * intval + (c - '0');
    }

    ungetc(c, stdin);    /* push non-digit character back onto input stream */

    *next_pointer_arg = intval;
    n_vals_converted++;
} else {
    /* saw no digit; processing has failed */
    ungetc(c, stdin);
    return n_vals_converted;
}

你会注意到我ungetc在代码的两个地方都添加了两个调用,在调用getcharthen 之后isdigit,代码刚刚发现它读取了一个不是数字的字符。

阅读一个字符然后改变主意似乎很奇怪,这意味着您必须“未阅读”它。在不阅读的情况下查看即将出现的字符(以确定它是否是数字)可能更有意义。或者,读取一个字符并发现它不是数字,如果要处理该字符的下一段代码就在此处scanf,则将其保留在局部变量中可能是有意义的c,而不是调用ungetc推送它返回输入流,然后再次调用getchar以从输入流中获取它。但是,在提到了其他两种可能性之后,我只想说,现在,我将继续使用ungetc.

到目前为止,我已经展示了您可能想象scanf的处理%d. 但是到目前为止我展示的代码仍然很不完整,因为它没有显示“秘密额外的力量”。它立即开始寻找数字字符;它不会跳过前导空格。

那么,这里是我的第三个也是最后一个%d-processing 代码示例片段:

/* skip leading whitespace */
while(isspace(c = getchar())) {
    /* discard */
}

if(isdigit(c)) {
    int intval;
    intval = c - '0';
    while(isdigit(c = getchar())) {
        intval = 10 * intval + (c - '0');
    }

    ungetc(c, stdin);    /* push non-digit character back onto input stream */

    *next_pointer_arg = intval;
    n_vals_converted++;
} else {
    /* saw no digit; processing has failed */
    ungetc(c, stdin);
    return n_vals_converted;
}

只要字符是空格,该初始循环就会读取并丢弃字符。它的形式与后面的循环非常相似,只要它们是数字就读取和处理字符。初始循环将读取比看起来应该多一个字符:当isspace调用失败时,这意味着它刚刚读取了一个空白字符。但这没关系,因为我们正要读取一个字符以查看它是否是第一个数字。

[脚注:这段代码还远非完美。一个非常重要的问题是它在解析过程中没有对 EOF 进行任何检查。另一个问题是它不寻找-+在数字之前,所以它不会处理负数。另一个更晦涩难懂的问题是,具有讽刺意味的是,看起来很明显的调用 likeisdigit(c)并不总是正确的——严格来说,它们需要稍微麻烦地呈现为isdigit((unsigned char)c).]

如果你还和我在一起,我的意思是用具体的方式说明这两点:

  • 能够自动跳过前导空格的原因%d是(a)规范说它应该这样做,并且(b)它有明确的代码来这样做,正如我的第三个示例所示。

  • 原因scanf总是在输入流上留下未处理的输入(即,在它确实读取和处理的输入之后的输入)是因为(a)再次,规范说它应该这样做,并且(b)它的代码通常撒上显式调用ungetc或等效项,以确保每个未处理的字符都保留在输入中,如我的第二个示例所示。

于 2021-08-27T11:38:08.777 回答
3

%d这是一些说明转换说明符行为的代码;它可能有助于理解这方面的scanf工作原理。这不是它在任何地方实际实现的方式,但它遵循相同的规则(更新以处理前导 +/- 符号、检查溢出等)。

#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>

/**
 * Mimics the behavior of the scanf %d conversion specifier.
 * Skips over leading whitespace, then reads and converts
 * decimal digits up to the next non-digit character.
 *
 * Returns EOF if no non-whitespace characters are
 * seen before EOF.
 *
 * Returns 0 if the first non-whitespace character
 * is not a digit.
 *
 * Returns 1 if at least one decimal digit was
 * read and converted.
 *
 * Stops reading on the first non-digit
 * character, pushes that character back
 * on the input stream.
 *
 * In the event of a signed integer overflow,
 * sets errno to ERANGE.
 */
int scan_to_int( FILE *stream, int *value )
{
  int conv = 0;
  int tmp = 0;
  int c;
  int sign = 0;

  /**
   * Skip over leading whitespace
   */
  while( ( c = fgetc( stream ) ) != EOF && isspace( c ) )
    ; // empty loop

  /**
   * If we see end of file before any non-whitespace characters,
   * return EOF.
   */
  if ( c == EOF )
    return c;

  /**
   * Account for a leading sign character.
   */
  if ( c == '-' || c == '+' )
  {
    sign = c;
    c = fgetc( stream );
  }

  /**
   * As long as we see decimal digits, read and convert them
   * to an integer value.  We store the value to a temporary
   * variable until we're done converting - we don't want
   * to update value unless we know the operation was
   * successful
   */
  while( c != EOF && isdigit( c ) )
  {
    /**
     * Check for overflow.  While setting errno on overflow
     * isn't required by the C language definition, I'm adding
     * it anyway.  
     */
    if ( tmp > INT_MAX / 10 - (c - '0') )
      errno = ERANGE;

    tmp = tmp * 10 + (c - '0');
    conv = 1;
    c = fgetc( stream );
  }

  /**
   * Push the last character read back onto the input
   * stream.
   */
  if ( c != EOF )
    ungetc( c, stream );

  /**
   * If we read a sign character (+ or -) but did not have a
   * successful conversion, then that character was not part
   * of a numeric string and we need to put it back on the
   * input stream in case it's part of a non-numeric input.
   */
  if ( sign && !conv )
    ungetc( sign, stream );

  /**
   * If there was a successful read and conversion,
   * update the output parameter.
   */
  if ( conv )
    *value = tmp * (sign == '-' ? -1 : 1);

  /**
   * Return 1 if the read was successful, 0 if there
   * were no digits in the input. 
   */
  return conv;
}

/**
 * Simple test program - attempts to read 1 integer from
 * standard input and display it.  Display any trailing
 * characters in the input stream up to and including
 * the next newline character.
 */
int main( void )
{
  int val;
  int r;

  errno = 0;

  /**
   * Read the next item from standard input and
   * attempt to convert it to an integer value.
   */
  if ( (r = scan_to_int( stdin, &val )) != 1 )
    printf( "Failed to read input, r = %d\n", r );
  else
    printf( "Read %d%s\n", val, errno == ERANGE ? " (overflow)" : "" );

  /**
   * If we didn't hit EOF, display the remaining
   * contents of the input stream.
   */
  if ( r != EOF )
  {
    fputs( "Remainder of input stream: {", stdout );
    int c;
    do {
      c = fgetc( stdin );
      switch( c )
      {
        case '\a': fputs( "\\a", stdout ); break;
        case '\b': fputs( "\\b", stdout ); break;
        case '\f': fputs( "\\f", stdout ); break;
        case '\n': fputs( "\\n", stdout ); break;
        case '\r': fputs( "\\r", stdout ); break;
        case '\t': fputs( "\\t", stdout ); break;
        default: fputc( c, stdout ); break;
      }
    } while( c != '\n' );

    fputs( "}\n", stdout );
  }

  return 0;
}

一些例子 - 首先,我们发出 EOF 信号(在我的例子中,通过输入Ctrl- D):

$ ./convert 
Failed to read input, r = -1

接下来,我们传入一个非数字字符串:

$ ./convert 
abcd
Failed to read input, r = 0
Remainder of input stream: {abcd\n}

由于没有进行任何转换,因此输入流的其余部分包含我们输入的所有内容(包括 hit 中的换行符Enter)。

接下来,一个带有非数字尾随字符的数字字符串:

$ ./convert 
12cd45
Read 12
Remainder of input stream: {cd45\n}

我们停止阅读'c'- 只有前导12被读取和转换。

由空格分隔的几个数字字符串 - 仅转换第一个字符串:

$ ./convert 
123 456 789
Read 123
Remainder of input stream: {\t456\t789\n}

以及带有前导空格的数字字符串:

$ ./convert 
      12345
Read 12345
Remainder of input stream: {\n}

处理主要标志:

$ ./convert 
-123abd
Read -123
Remainder of input stream: {abd\n}

$ ./convert 
    +456
Read 456
Remainder of input stream: {\n}

$ ./convert 
-abcd
Failed to read input, r = 0
Remainder of input stream: {-abcd\n}

最后,我们添加了一个溢出检查 - 注意scanfC 语言标准不需要检查溢出,但我认为这是一件有用的事情:

$ ./convert 
123456789012345678990012345667890
Read -701837006 (overflow)

输入流的其余部分: {\n} %d%i%f%s等,都跳过前导空格,因为在这些情况下,除了充当输入之间的分隔符之外,空格没有意义。 %c并且%[不要跳过前导空格,因为它可能那些特定的转换有意义(有时您知道刚刚读取的字符是空格、制表符还是换行符)。

正如史蒂夫指出的那样,Cstdio例程中的空格处理一直是一个棘手的问题,没有一种解决方案总是效果最好,特别是因为不同的库例程处理它的方式不同。

于 2021-08-27T15:00:30.687 回答
3

您的方法存在一些问题:

  • 您使用FILE对象的未记录的、特定于实现的成员,该成员_Placeholder可能在不同平台上可用也可能不可用,并且其内容无论如何都是特定于实现的。
  • 您使用scanf_s(),这是 Microsoft 特定的所谓安全版本scanf():此功能是可选的,可能并非在所有平台上都可用。此外,Microsoft 的实现不符合 C 标准:例如,后面传递的 size 参数&ch在 VS 中以类型为文档,UINT而 C 标准将其指定为size_t,在 64 位版本的 Windows 上具有不同的大小。

scanf()使用起来相当棘手:即使是经验丰富的 C 程序员也会被它的许多怪癖和陷阱所困扰。在您的代码中,您测试%d%c,它们的行为非常不同:

  • for %d,scanf()将首先读取并丢弃任何空白字符,例如空格、TAB 和换行符,然后读取可选的符号+-,然后它希望读取至少一个数字并在它得到一个不是数字的字节时停止并离开输入流中的这个字节,将其推回ungetc()或等效。如果无法读取任何数字,则转换失败并且第一个非数字字符在输入流中保持未决状态,但之前的字节不一定被推回。
  • 处理%c要简单得多:读取单个字节并将其存储到char对象中,或者如果流位于文件末尾,则转换失败。

如果输入流绑定到终端,则处理%c之后%d会很棘手,因为用户将在预期的数字之后输入换行符,%d并且将立即为%c. 该程序可以通过在格式字符串%c之前插入一个空格来忽略预期字节之前的空格:%cres = scanf(" %c", &ch);

为了更好地理解 的行为scanf(),您应该输出每个调用的返回值和流当前位置,通过ftell(). 首先将流设置为二进制模式以使返回值ftell()恰好是从文件开头开始的字节数也更可靠。

这是修改后的版本:

#include <stdio.h>

#ifdef _MSC_VER
#include <fcntl.h>
#include <io.h>
#endif

int main() {
    int x, res;
    char ch;
    long A, B, C, D;

#ifdef _MSC_VER
    _setmode(_fileno(stdin), _O_BINARY);
#endif

    A = ftell(stdin);
    printf("A : %ld\n", A);

    x = 0;
    res = scanf_s("%d", &x);

    B = ftell(stdin);
    printf("B : %ld, res=%d, x=%d\n", B, res, x);

    rewind(stdin);
    C = ftell(stdin);
    printf("C : %ld\n", C);

    ch = 0;
    res = scanf_s("%c", &ch, 1);
    D = ftell(stdin);
    printf("D : %ld, res=%d, ch=%d (%c)\n", D, res, ch, ch);

    return 0;
}
于 2021-08-27T11:45:25.787 回答