如果你不想接受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。它可能看起来像：

#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;
}

一般来说，我认为最好从输入中读取所有内容（当然是在缓冲区大小的范围内），然后验证输入是否确实是正确的格式。
在您的例子中，您会看到使用像 * f1f1f * 这样的字符串的错误，因为您没有阅读整个STDIN缓冲区。因此，当您再次调用scanf(...)时，STDIN中仍然有数据，因此首先读入这些数据，而不是提示用户输入更多的输入。要阅读STDIN的全部内容，您应该执行以下操作（部分代码从Paxdiablo的答案中借用：https://stackoverflow.com/a/4023921/2694511）：

#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语言写了，所以如果这个例子中有任何错误，我提前道歉。我也没有机会在发布之前编译和测试这段代码，因为我现在很匆忙。

如果您正在阅读一个输入流，您知道它是一个文本流，但您不确定它只由整数组成，那么就读取字符串。
此外，一旦您读取了一个字符串，并希望查看它是否是一个整数，请使用标准库转换例程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;
}

添加注解：如果将base（strtol()的最后一个参数）从10更改为0，则会获得额外的功能，即代码将十六进制数和八进制数（分别以0x和00开头的字符串）转换为整数。