Compruebe si la entrada es tipo entero en C

La trampa es que no puedo usar atoi o cualquier otra función como esa (estoy bastante seguro de que se supone que debemos confiar en las operaciones matemáticas).

int num; scanf("%d",&num); if(/* num is not integer */) { printf("enter integer"); return; } 

He intentado:

 (num*2)/2 == num num%1==0 if(scanf("%d",&num)!=1) 

pero ninguno de estos funcionó.

¿Algunas ideas?

num siempre contendrá un número entero porque es un int . El verdadero problema con su código es que no verifica el valor de retorno de scanf . scanf devuelve el número de elementos leídos con éxito, por lo que en este caso debe devolver 1 para los valores válidos. Si no, se ingresó un valor entero inválido y la variable num probablemente no se modificó (es decir, todavía tiene un valor arbitrario porque no la inicializó).

A partir de su comentario, solo desea permitir que el usuario ingrese un número entero seguido de la tecla Intro. Desafortunadamente, esto no se puede lograr simplemente mediante scanf("%d\n") , pero aquí hay un truco para hacerlo:

 int num; char term; if(scanf("%d%c", &num, &term) != 2 || term != '\n') printf("failure\n"); else printf("valid integer followed by enter key\n"); 

Primero debe leer su entrada como una cadena, luego analizar la cadena para ver si contiene caracteres numéricos válidos. Si lo hace, entonces puede convertirlo a un número entero.

 char s[MAX_LINE]; valid = FALSE; fgets(s, sizeof(s), stdin); len = strlen(s); while (len > 0 && isspace(s[len - 1])) len--; // strip trailing newline or other white space if (len > 0) { valid = TRUE; for (i = 0; i < len; ++i) { if (!isdigit(s[i])) { valid = FALSE; break; } } } 

Hay varios problemas con el uso de scanf con el especificador de conversión %d para hacer esto:

  1. Si la cadena de entrada comienza con un número entero válido (como “12abc”), entonces el “12” se leerá de la secuencia de entrada y se convertirá y asignará a num , y scanf devolverá 1, por lo que indicará el éxito cuando (probablemente) no debería;

  2. Si la cadena de entrada no comienza con un dígito, entonces scanf no leerá ningún carácter de la secuencia de entrada, num no se cambiará, y el valor de retorno será 0;

  3. No especifica si necesita manejar formatos no decimales, pero esto no funcionará si tiene que manejar valores enteros en formatos octales o hexadecimales (0x1a). El especificador de conversión %i maneja formatos decimales, octales y hexadecimales, pero aún tiene los dos primeros problemas.

Antes que nada, necesitarás leer la entrada como una cadena (preferiblemente usando fgets ). Si no puedes usar atoi , probablemente tampoco puedas usar strtol . Por lo tanto, deberás examinar cada personaje de la cadena. La forma segura de verificar valores de dígitos es usar la función de la biblioteca isdigit (también están las funciones isodigit y isxdigit para verificar los dígitos octales y hexadecimales, respectivamente), como

 while (*input && isdigit(*input)) input++; 

(si ni siquiera está autorizado a usar isdigit , isodigit o isxdigit , isxdigit su profesor / profesor para que la tarea sea más difícil de lo que realmente debe ser).

Si necesita poder manejar formatos octales o hexadecimales, entonces se vuelve un poco más complicado. La convención de C es que los formatos octales tengan un dígito inicial de 0 y para los formatos hexadecimales tengan un 0x líder. Entonces, si el primer carácter que no es un espacio en blanco es un 0, debe verificar el siguiente carácter antes de saber qué formato no decimal usar.

El esquema básico es

  1. Si el primer carácter que no es un espacio en blanco no es un dígito decimal “-“, “+”, “0” o distinto de cero, entonces esta no es una cadena entera válida;
  2. Si el primer carácter que no es espacio en blanco es ‘-‘, entonces este es un valor negativo; de lo contrario, asumimos un valor positivo;
  3. Si el primer carácter es ‘+’, entonces este es un valor positivo;
  4. Si el primer carácter que no es de espacios en blanco y el que no es signo es un dígito decimal distinto de cero, entonces la entrada está en formato decimal, y usará isdigit para verificar los caracteres restantes;
  5. Si el primer carácter que no es de espacio en blanco y el signo no es un ‘0’, entonces la entrada está en formato octal o hexadecimal;
  6. Si el primer carácter que no sea de espacios en blanco y el signo no es un ‘0’ y el siguiente carácter es un dígito de ‘0’ a ‘7’, entonces la entrada está en formato octal, y utilizará isodigit para verificar los caracteres restantes ;
  7. Si el primer carácter que no es un espacio en blanco y el que no es signo es un 0 y el segundo carácter es x o X , entonces la entrada está en formato hexadecimal y usará isxdigit para verificar los caracteres restantes;
  8. Si alguno de los caracteres restantes no cumple la función de verificación especificada anteriormente, esta no es una cadena de enteros válida.

Primero pregúntese cómo esperaría que este código NO devuelva un número entero:

 int num; scanf("%d",&num); 

Usted especificó la variable como tipo entero, luego scanf , pero solo para un entero ( %d ).

¿Qué más podría contener en este momento?

Revisé la entrada anterior de todos, lo cual fue muy útil, e hice una función que era apropiada para mi propia aplicación. La función realmente solo está evaluando que la entrada del usuario no es un “0”, pero fue lo suficientemente bueno para mi propósito. ¡Espero que esto ayude!

 #include int iFunctErrorCheck(int iLowerBound, int iUpperBound){ int iUserInput=0; while (iUserInput==0){ scanf("%i", &iUserInput); if (iUserInput==0){ printf("Please enter an integer (%i-%i).\n", iLowerBound, iUpperBound); getchar(); } if ((iUserInput!=0) && (iUserInputiUpperBound)){ printf("Please make a valid selection (%i-%i).\n", iLowerBound, iUpperBound); iUserInput=0; } } return iUserInput; } 

Prueba esto…

 #include  int main (void) { float a; int q; printf("\nInsert number\t"); scanf("%f",&a); q=(int)a; ++q; if((q - a) != 1) printf("\nThe number is not an integer\n\n"); else printf("\nThe number is an integer\n\n"); return 0; } 

Creo que es más fácil de usar:

 #include /* This program checks if the entered input is an integer * or provides an option for the user to re-enter. */ int getint() { int x; char c; printf("\nEnter an integer (say -1 or 26 or so ): "); while( scanf("%d",&x) != 1 ) { c=getchar(); printf("You have entered "); putchar(c); printf(" in the input which is not an integer"); while ( getchar() != '\n' ) ; //wasting the buffer till the next new line printf("\nEnter an integer (say -1 or 26 or so ): "); } return x; } int main(void) { int x; x=getint(); printf("Main Function =>\n"); printf("Integer : %d\n",x); return 0; } 

Desarrollé esta lógica usando get y away from scanf molestia:

 void readValidateInput() { char str[10] = { '\0' }; readStdin: fgets(str, 10, stdin); //printf("fgets is returning %s\n", str); int numerical = 1; int i = 0; for (i = 0; i < 10; i++) { //printf("Digit at str[%d] is %c\n", i, str[i]); //printf("numerical = %d\n", numerical); if (isdigit(str[i]) == 0) { if (str[i] == '\n')break; numerical = 0; //printf("numerical changed= %d\n", numerical); break; } } if (!numerical) { printf("This is not a valid number of tasks, you need to enter at least 1 task\n"); goto readStdin; } else if (str[i] == '\n') { str[i] = '\0'; numOfTasks = atoi(str); //printf("Captured Number of tasks from stdin is %d\n", numOfTasks); } } 
 printf("type a number "); int converted = scanf("%d", &a); printf("\n"); if( converted == 0) { printf("enter integer"); system("PAUSE \n"); return 0; } 

scanf () devuelve el número de especificadores de formato que coinciden, por lo que devolverá cero si el texto ingresado no puede interpretarse como un entero decimal

Estaba teniendo el mismo problema, finalmente descubrí qué hacer:

 #include  #include  int main () { int x; float check; reprocess: printf ("enter a integer number:"); scanf ("%f", &check); x=check; if (x==check) printf("\nYour number is %d", x); else { printf("\nThis is not an integer number, please insert an integer!\n\n"); goto reprocess; } _getch(); return 0; } 

He estado buscando una solución más simple usando únicamente loops y declaraciones if, y esto es lo que se me ocurrió. El progtwig también funciona con enteros negativos y rechaza correctamente cualquier entrada mixta que pueda contener enteros y otros caracteres.


 #include  #include  // Used for atoi() function #include  // Used for strlen() function #define TRUE 1 #define FALSE 0 int main(void) { char n[10]; // Limits characters to the equivalent of the 32 bits integers limit (10 digits) int intTest; printf("Give me an int: "); do { scanf(" %s", n); intTest = TRUE; // Sets the default for the integer test variable to TRUE int i = 0, l = strlen(n); if (n[0] == '-') // Tests for the negative sign to correctly handle negative integer values i++; while (i < l) { if (n[i] < '0' || n[i] > '9') // Tests the string characters for non-integer values { intTest = FALSE; // Changes intTest variable from TRUE to FALSE and breaks the loop early break; } i++; } if (intTest == TRUE) printf("%i\n", atoi(n)); // Converts the string to an integer and prints the integer value else printf("Retry: "); // Prints "Retry:" if tested FALSE } while (intTest == FALSE); // Continues to ask the user to input a valid integer value return 0; } 

Este método funciona para todo (enteros e incluso dobles) excepto cero (lo llama inválido):

El ciclo while es solo para la entrada repetitiva del usuario. Básicamente, comprueba si el entero x / x = 1. Si lo hace (como lo haría con un número), es un número entero / doble. Si no lo hace, obviamente no lo es. Zero falla la prueba sin embargo.

 #include  #include  void main () { double x; int notDouble; int true = 1; while(true) { printf("Input an integer: \n"); scanf("%lf", &x); if (x/x != 1) { notDouble = 1; fflush(stdin); } if (notDouble != 1) { printf("Input is valid\n"); } else { printf("Input is invalid\n"); } notDouble = 0; } } 

Encontré una forma de comprobar si la entrada dada es un número entero o no usando la función atoi ().

Lee la entrada como una cadena y usa la función atoi () para convertir la cadena en un entero.

La función atoi () devuelve el número entero si la cadena de entrada contiene un entero, de lo contrario devolverá 0. Puede verificar el valor de retorno de la función atoi () para saber si la entrada dada es un número entero o no.

Hay muchas más funciones para convertir una cadena en larga, doble, etc. Consulte la biblioteca estándar “stdlib.h” para obtener más información.

Nota: Funciona solo para números que no sean cero.

 #include #include int main() { char *string; int number; printf("Enter a number :"); scanf("%s", string); number = atoi(string); if(number != 0) printf("The number is %d\n", number); else printf("Not a number !!!\n"); return 0; }