Recibir int seguro

[patilanz]

Hola he buscado por internet como recibir valores por internet de tal manera que sea int y si es un bucle que comprueba los datos no se pare si se inserta una letra.
De modo que este codigo no funciona:

Código (cpp) [Seleccionar] Expandir

int d;
do{
cout << msg;
cin >> d;
cin.clear();
//while(cin.get()!='\n');
}while(cin.fail());
return d;

Como comprobar un int?

Saludos

[rir3760]

Esa pregunta ya se ha respondido en varias ocasiones en los foros, solo tienes que utilizar el motor de búsqueda para encontrar los temas relacionados. Por ejemplo Validar algunas cosas en C++.

Un saludo

[leosansan]

El método que propones tiene un pero, si introduces 12as toma 12 como int.

Vero más seguro elñ siguiente código, y aunque está en C no creo que patilanz tenga problema en adaptarlo a C++:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX_DIGITOS  100

int comprobar_cadena_como_numero (char numero[MAX_DIGITOS]);

int main(){

  char cadena[MAX_DIGITOS];
  do{
    printf("\nIntroduce un numero entero: ");
    scanf("%s",&cadena);
    }while (comprobar_cadena_como_numero(cadena)!=2);
    printf("\nentero: %d\n",atoi (cadena));
    return EXIT_SUCCESS;
}

int comprobar_cadena_como_numero (char cadena[MAX_DIGITOS]){
    int i;
    for (i=0;cadena[i];i++)
      if (!isdigit(cadena[i]))
            return 1;
    return 2;
}

¡¡¡¡ Saluditos! ..... !!!!

[patilanz]

Gracias ahora consegui hacer lo.

Código (cpp) [Seleccionar] Expandir

int getInt(string msg){
string d;
do{
cout << msg;
cin >> d;
}while(!isInt(d));
return atoi(d.data());
}


int isInt(string &str){
for(size_t i=0;i<str.size();i++){
if(!isdigit(str[i])){
return 0;
}
}
return 1;
}

Pero una pregunta. El código de c que utiliza char[] no daría error si se introduce un valor mayor que el size?
Muchas gracias

[leosansan]

Gracias ahora consegui hacer lo.
.......................................................
Pero una pregunta. El código de c que utiliza char[] no daría error si se introduce un valor mayor que el size?
Muchas gracias

¿Y quién es el animalito que al pedirle un entero introduce más de 100 dígitos?.

Claro que haberlos "haylos" pero todo sería cuestión de hacer una limpieza adicional del buffer.

¡¡¡¡ Saluditos! ..... !!!!

[patilanz]

Me refiero a insertar código desde fuera sustituyendo la memoria cuando se acabe el buffer. O no es posible?

Con una clase que contiene cadenas con memoria dinamica esto no pasa y en este caso ? con char[size] ??

[Yoel Alejandro]

Claro, el "desbordamiento de buffer" es un problema típico en la programación, y que por supuesto debemos evitar.

Para C (en C++ el tamaño del arreglo se ajusta automáticamente) una solución sería usar fgets(char *s, int size, FILE *stream), que limita la cantidad de caracteres leídos a size - 1 (se resta uno porque la última posición está reservada para el nulo de terminación). En stream hemos de poner stdin para que lea de la entrada estándar (hay unas consideraciones con fgets() que explicaré al final)

Código (cpp) [Seleccionar] Expandir


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

int getInt(char *);
int isInt(char * s);

int main( ) {

int x;
char msg[] = "Intro numero: ";

printf("Numero es: %d\n", getInt(msg));
}

int getInt(char *msg) {

#define N 3
char s[N + 1];
int i;
char clean_return;

do {
printf("%s", msg);
fgets(s, N + 1, stdin);

/* reemplazar '\n' (si se encuentra) por '\0' */
i = -1;
clean_return = 1;
while ( s[++i] != '\0' )
if ( s[i] == '\n' ) {
s[i] = '\0';
clean_return = 0;
break;
}

/* si no se pasó '\n' al arreglo, limpiarlo del bufer de entrada */
if ( clean_return ) getchar();
} while( *s == '\0' || !isInt(s) );

return atoi(s);
}

int isInt(char * s) {

int i = -1;

while ( s[++i] != '\0' ) {
if( !isdigit(s[i]) )
return 0;
}
return 1;
}

El programa pide al usuario un cadena, que es evaluada como entero siempre y cuando todos sus caracteres sean numéricos. De lo contrario, pide de nuevo. Al final imprime lo que leyó, para verificar.

Como ya se explicó, si por ejemplo declaras un arreglo char[] de N+1 caracteres, entonces fgets() lee como mucho N caractares. Si el fin de línea se encuentra dentro de esos N caracteres (si la cadena tiene una longitud menor N) entonces el fin de linea '\n' es pasado al arreglo. De lo contrario, (si la longitud de la cadena es mayor o igual a N) el '\n' no se pasa al arreglo y queda "pendiente" en el flujo de entrada del teclado. Por eso es necesario eliminarlo con getchar()

Se podría hacer una modificación al isInt() con el objeto de admitir un único carácter de signo '-' al inicio de la cadena, así permitir números negativos.

El código propuesto está en C, lo que implementa una solución más "básica" que C++. Creo que una simple operación de lectura de datos por teclado no exige invocar el complejo modelo de objetos de E/S de C++ ..... (bueno aunque de ahí en adelante no opino más, ello depende del gusto del programador)

[ivancea96]

Código (cpp) [Seleccionar] Expandir


    //Dada una string 's'...
   /** INT && UINT **/
    bool sign=false;
   if(s[0]=='-')
       sign=true;
   if(allNumeric(s.substr(sign, s.size()))){
       if(sign){
           if(minorEqual(s.substr(1, s.size()), "2147483648"))
               type+=type_int;
       }else{
           if(minorEqual(s.substr(0, s.size()), "2147483647"))
               //Se puede convertir a INT
           if(minorEqual(s.substr(0, s.size()), "4294967295"))
               //Se puede convertir a Unsigned INT
       }
   }


[leosansan]

Claro, el "desbordamiento de buffer" es un problema típico en la programación, y que por supuesto debemos evitar.

Para C (en C++ el tamaño del arreglo se ajusta automáticamente) una solución sería usar fgets
...................................

Tiene una pequeñita pega el "rollo" de código que empleas:

* Si introduces 12 te lo da como bueno y ¿no era de tres dígitos el número a introducir?.

* Si introduces 123456 te da como bueno el 123 y ¿no es posible que se hallan equivocado al introducir los tres primeros dígitos?.

Reconozco que mi propuesta no es tan completa y compleja como la que propone ivancea96 pero sirve para estos casos de "andar por casa" y para hacerlo todo a "pelo" calculo hasta la longitud con mi propia función, más que nada por variar ya que antes utilice isdigit:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#define MAX_DIGITOS  100

int comprobar_cadena_como_numero (char numero[MAX_DIGITOS]);
int longitud_cadena (char cadena[MAX_DIGITOS]);
/****************************************************/
int main(){

  char cadena[MAX_DIGITOS];
  do{
    printf("\nIntroduce un numero entero de cinco digitos: ");
    scanf("%s",&cadena);
    while (getchar()!='\n');
    }while (comprobar_cadena_como_numero(cadena)!=2 || longitud_cadena(cadena) !=5);
    printf("\nentero: %d\n",atoi (cadena));
    return EXIT_SUCCESS;
}
/****************************************************/
int comprobar_cadena_como_numero (char cadena[MAX_DIGITOS]){
    int i;
    for (i=0;cadena[i];i++)
       if (cadena[i]<'0' || cadena[i]>'9')
            return 1;
    return 2;
}

/****************************************************/
int longitud_cadena (char cadena[MAX_DIGITOS]){
    int i;
    for (i=0;cadena[i];i++);
    return i;
}
/****************************************************/


Ya sé que tiene una pequeña pega pero este código sólo admite cindo dígitos, ni uno más ni uno menos.

Y todo esto es para pasar el tiempo y compartir conocimientos. Yo sigo aprendiendo de todos ustedes. Gracias.

¡¡¡¡ Saluditos! ..... !!!!

[Yoel Alejandro]

Ah, leosansan pero es mi intención fue precisamente recibir una cadena de 3 o menos dígitos. O sea, si aceptamos en forma estricta la longitud y el número fuera 12 tendrías que escribir 012, que es un fastidio, puff

Una solución sería definir un búfer más grande (por ello la constante N), digamos de 10 o 20 caracteres, así el usuario dispone de todos esos espacios para escribir su número (grande o pequeño). Ahora si él se equivoca tecleado el número, es culpa de él, jajajajajajaja

La otra opción de que sea una cantidad fija de dígitos, ni más ni menos, también puede ser deseable. Eso depende de cómo el diseñador quiera presentar la interfaz de su programa, y de la aplicación que involucre. Si por ejemplo vas a meter un cifra cuya cantidad de dígitos se conoce con exactitud (cédula de identidad, código de un producto en un almacén, o el carnet de un trabajador) vale el segundo enfoque. Pero si la longitud es variable y desconocida vale el primer enfoque con un búfer tan grande como la máxima longitud admisible.

Ya eso depende del caso que se quiera trabajar ..... Y saludos como siempre