在 while 循环中正确使用 scanf 来验证输入

Question

我做了这段代码：

/*here is the main function*/
int x , y=0, returned_value;
int *p = &x;
while (y<5){
    printf("Please Insert X value\n");
    returned_value = scanf ("%d" , p);
    validate_input(returned_value, p);
    y++;
}

这个函数：

void validate_input(int returned_value, int *p){
    getchar();
    while (returned_value!=1){
        printf("invalid input, Insert Integers Only\n");
        getchar();
        returned_value = scanf("%d", p);
    }
}

虽然它通常工作得非常好，但当我插入例如“1f1”时，它接受了“1”并且没有报错，当我插入“f1f1f”时，它读取了两次并破坏了第二次读取/扫描等等（即第一次读取打印出“无效输入，仅插入整数”，而不是等待用户重新阅读第一次读取，它继续到第二次读取并再次打印出“无效输入，仅插入整数”...）

它需要一个最后的修饰，我已经阅读了很多答案，但找不到它。

- anon

---

注意：如果validate_input()返回值为EOF，则会出现无限递归。 - chux - Reinstate Monica

如果您不想接受1f1作为有效输入，则使用scanf是错误的函数。 - Support Ukraine

@chux，我尝试了EOF，但完全不起作用！ - Yahya

@4386427 那我应该使用什么？ - Yahya

如果OP不想使用scanf()，建议如何测试输入是否合理。 - chux - Reinstate Monica

Answer 1

如果你不想接受1f1作为有效输入，那么scanf就不是正确的函数，因为scanf在找到匹配项后就会返回。

相反，先读取整行，然后检查是否只包含数字。之后可以调用sscanf。

类似这样的代码：

#include <stdio.h>

int validateLine(char* line)
{
    int ret=0;
    
    // Allow negative numbers
    if (*line && *line == '-') line++;
    
    // Check that remaining chars are digits
    while (*line && *line != '\n')
    {
        if (!isdigit(*line)) return 0; // Illegal char found

        ret = 1;  // Remember that at least one legal digit was found
        ++line;
    }
    return ret;
}

int main(void) {
    char line[256];
    int i;

    int x , y=0;
    while (y<5)
    {
        printf("Please Insert X value\n");
        if (fgets(line, sizeof(line), stdin)) // Read the whole line
        {
            if (validateLine(line))  // Check that the line is a valid number
            {
                // Now it should be safe to call sscanf - it shouldn't fail
                // but check the return value in any case
                if (1 != sscanf(line, "%d", &x)) 
                {
                    printf("should never happen");
                    exit(1);
                }

                // Legal number found - break out of the "while (y<5)" loop
                break;
            }
            else
            {
                printf("Illegal input %s", line);
            }
        }
        y++;
    }
    
    if (y<5)
        printf("x=%d\n", x);
    else
        printf("no more retries\n");

    return 0;
}

输入

1f1
f1f1

-3

输出

Please Insert X value
Illegal input 1f1
Please Insert X value
Illegal input f1f1
Please Insert X value
Illegal input 
Please Insert X value
x=-3

另一种方法 - 避免使用scanf

你可以让你的函数计算数字，从而完全绕过scanf。它可能看起来像这样：

#include <stdio.h>

int line2Int(char* line, int* x)
{
    int negative = 0;
    int ret=0;
    int temp = 0;
    
    if (*line && *line == '-') 
    {
        line++;
        negative = 1;
    }
    else if (*line && *line == '+')  // If a + is to be accepted
        line++;                      // If a + is to be accepted
       
    while (*line && *line != '\n')
    {
        if (!isdigit(*line)) return 0; // Illegal char found
        ret = 1;

            // Update the number
        temp = 10 * temp;
        temp = temp + (*line - '0');

        ++line;
    }
    
    if (ret)
    {
        if (negative) temp = -temp;
        *x = temp;
    }
    return ret;
}

int main(void) {
    char line[256];
    int i;

    int x , y=0;
    while (y<5)
    {
        printf("Please Insert X value\n");
        if (fgets(line, sizeof(line), stdin)) 
        {
            if (line2Int(line, &x)) break;  // Legal number - break out

            printf("Illegal input %s", line);
        }
        y++;
    }
    
    if (y<5)
        printf("x=%d\n", x);
    else
        printf("no more retries\n");

    return 0;
}

- Support Ukraine

---

这段代码中的 fgets() 是最佳方法。缺点是不接受 "+123" 或 " 456"（前导空格）。最终，使用 strol() 可能更容易些。 - chux - Reinstate Monica

@chux - 感谢您的建议。我忘记了可以很容易地添加+。不确定OP是否认为前面的空格是有效的，但您提出了一个很好的观点。我没有使用strol的经验，但快速阅读建议它可能会很方便。也许您可以给OP一个使用strol的好例子（因为我不能） :-) - Support Ukraine

Answer 2

总的来说，我认为最好从输入中读取所有内容（当然，范围应该在你的缓冲区大小内），然后验证输入是否确实是正确的格式。

在您的情况下，使用像f1f1f这样的字符串会出现错误，因为您没有读取整个 STDIN 缓冲区。因此，当您再次调用 scanf(...) 时，仍然存在 STDIN 中的数据，因此首先读取该数据，而不是提示用户输入更多内容。要读取所有 STDIN，请执行以下操作（代码部分借鉴自 Paxdiablo 的答案：https://dev59.com/1m865IYBdhLWcg3wCp4_#4023921）：

#include <stdio.h>
#include <string.h>
#include <stdlib.h> // Used for strtol

#define OK          0
#define NO_INPUT    1
#define TOO_LONG    2
#define NaN         3 // Not a Number (NaN)

int strIsInt(const char *ptrStr){
    // Check if the string starts with a positive or negative sign
    if(*ptrStr == '+' || *ptrStr == '-'){
        // First character is a sign. Advance pointer position
        ptrStr++;
    }

    // Now make sure the string (or the character after a positive/negative sign) is not null
    if(*ptrStr == NULL){
        return NaN;
    }

    while(*ptrStr != NULL){
        // Check if the current character is a digit
        // isdigit() returns zero for non-digit characters
        if(isdigit( *ptrStr ) == 0){
            // Not a digit
            return NaN;
        } // else, we'll increment the pointer and check the next character
        ptrStr++;
    }

    // If we have made it this far, then we know that every character inside of the string is indeed a digit
    // As such, we can go ahead and return a success response here
    // (A success response, in this case, is any value other than NaN)
    return 0;
}

static int getLine (char *prmpt, char *buff, size_t sz) {
    int ch, extra;

    // Get line with buffer overrun protection.
    if (prmpt != NULL) {
        printf ("%s", prmpt);
        fflush (stdout);
    }
    if (fgets (buff, sz, stdin) == NULL)
        return NO_INPUT;

    // If it was too long, there'll be no newline. In that case, we flush
    // to end of line so that excess doesn't affect the next call.
    // (Per Chux suggestions in the comments, the "buff[0]" condition
    //   has been added here.)
    if (buff[0] && buff[strlen(buff)-1] != '\n') {
        extra = 0;
        while (((ch = getchar()) != '\n') && (ch != EOF))
            extra = 1;
        return (extra == 1) ? TOO_LONG : OK;
    }

    // Otherwise remove newline and give string back to caller.
    buff[strlen(buff)-1] = '\0';
    return OK;
}

void validate_input(int responseCode, char *prompt, char *buffer, size_t bufferSize){
    while( responseCode != OK ||
            strIsInt( buffer ) == NaN )
    {
        printf("Invalid input.\nPlease enter integers only!\n");
        fflush(stdout); /* It might be unnecessary to flush here because we'll flush STDOUT in the
                           getLine function anyway, but it is good practice to flush STDOUT when printing
                           important information. */
        responseCode = getLine(prompt, buffer, bufferSize); // Read entire STDIN
    }

    // Finally, we know that the input is an integer
}

int main(int argc, char **argv){
    char *prompt = "Please Insert X value\n";
    int iResponseCode;
    char cInputBuffer[100];
    int x, y=0;
    int *p = &x;
    while(y < 5){
        iResponseCode = getLine(prompt, cInputBuffer, sizeof(cInputBuffer)); // Read entire STDIN buffer
        validate_input(iResponseCode, prompt, cInputBuffer, sizeof(cInputBuffer));

        // Once validate_input finishes running, we should have a proper integer in our input buffer!
        // Now we'll just convert it from a string to an integer, and store it in the P variable, as you
        // were doing in your question.
        sscanf(cInputBuffer, "%d", p);
        y++;
    }
}

作为免责声明/注释：我已经很久没有写过C语言了，如果这个例子中有任何错误，我提前道歉。因为我现在很匆忙，所以在发布之前也没有机会编译和测试这段代码。

- Spencer D

---

如果 (buff[strlen(buff)-1] != '\n')，则存在黑客攻击风险，因为 buf[0] 可能是 0。建议使用 if (buff[0] && buff[strlen(buff)-1] != '\n') 或 buff[strcspn(buff,"\n")] = '\0';。 - chux - Reinstate Monica

@chux，感谢您的建议。我很快就会进行编辑。我是从我的答案中链接的帖子中复制了该函数，所以我没有费心去编辑它或检查确保一切安全。 - Spencer D

谢谢你的回答，加一。 - Yahya

Answer 3

如果您正在阅读一个输入流，您知道它是一个文本流，但您不确定它是否只包含整数，则读取字符串。

此外，一旦您读取了一个字符串并想查看它是否为整数，请使用标准库转换例程 strtol()。通过这样做，您既可以确认它是一个整数，又可以将其转换为 long 类型。

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

bool convert_to_long(long *number, const char *string)
{
    char *endptr;

    *number = strtol(string, &endptr, 10);

    /* endptr will point to the first position in the string that could
     * not be converted.  If this position holds the string terminator
     * '\0' the conversion went well.  An empty input string will also
     * result in *endptr == '\0', so we have to check this too, and fail
     * if this happens.
     */

    if (string[0] != '\0' && *endptr == '\0')
        return false; /* conversion succesful */

    return true; /* problem in conversion */
}

int main(void)
{
    char buffer[256];

    const int max_tries = 5;
    int tries = 0;

    long number;

    while (tries++ < max_tries) {
        puts("Enter input:");

        scanf("%s", buffer);

        if (!convert_to_long(&number, buffer))
            break; /* returns false on success */

        printf("Invalid input. '%s' is not integer, %d tries left\n", buffer,
               max_tries - tries);
    }

    if (tries > max_tries)
        puts("No valid input found");
    else
        printf("Valid input: %ld\n", number);

    return EXIT_SUCCESS;
}

添加说明: 如果将 strtol() 的最后一个参数从10更改为零，则您的代码将具有将十六进制数字和八进制数字（以0x 和 00 开头的字符串）转换为整数的附加功能。

- Kusalananda

Answer 4

我采用了@4386427的想法，并添加了代码来覆盖它所遗漏的部分（前导空格和+号），我进行了多次测试，在所有可能的情况下都完美地工作。

#include<stdio.h>
#include <ctype.h>
#include <stdlib.h>

int validate_line (char *line);

int main(){
char line[256];
int y=0;
long x;

while (y<5){
   printf("Please Insert X Value\n");

   if (fgets(line, sizeof(line), stdin)){//return 0 if not execute
            if (validate_line(line)>0){ // check if the string contains only numbers
                    x =strtol(line, NULL, 10); // change the authentic string to long and assign it
                    printf("This is x %d" , x);
                    break;
            }
            else if (validate_line(line)==-1){printf("You Have Not Inserted Any Number!.... ");}
            else {printf("Invalid Input, Insert Integers Only.... ");}
   }


y++;
if (y==5){printf("NO MORE RETRIES\n\n");}
else{printf("%d Retries Left\n\n", (5-y));}

}
return 0;}


int validate_line (char *line){
int returned_value =-1;
/*first remove spaces from the entire string*/
char *p_new = line;
char *p_old = line;
while (*p_old != '\0'){// loop as long as has not reached the end of string
       *p_new = *p_old; // assign the current value the *line is pointing at to p
            if (*p_new != ' '){p_new++;} // check if it is not a space , if so , increment p
        p_old++;// increment p_old in every loop
        }
        *p_new = '\0'; // add terminator


if (*line== '+' || *line== '-'){line++;} // check if the first char is (-) or (+) sign to point to next place


while (*line != '\n'){
    if (!(isdigit(*line))) {return 0;} // Illegal char found , will return 0 and stop because isdigit() returns 0 if the it finds non-digit
    else if (isdigit(*line)){line++; returned_value=2;}//check next place and increment returned_value for the final result and judgment next.
     }

     return returned_value; // it will return -1 if there is no input at all because while loop has not executed, will return >0 if successful, 0 if invalid input

}

- Yahya