Validar solo números en un INT

[RGT]

Código:

int NumeroLetras;

do
    {
        cout << "\nN\243mero de letras de la palabra: ";
        cin >> NumeroLetras;
    } while(ValidarNumeroIngresado(NumeroLetras));

/*  Validar el número ingresado
------------------------------------------------------------------------*/
int ValidarNumeroIngresado(int NumeroLetras)
{
    if (NumeroLetras < 48 || NumeroLetras > 57)
        return 0;

    else
        return 1;
}

Hola, me deje llevar por la tabla del codigo ASCHII, si se ingresa algo fuera de ese rango, no es considerado un número, pero no funciona.

Alguien sabe mi error?.
Investigué en Google y encuentro muchas formas diferentes, pero para serles sincero no las entiendo.

Espero puedan ayudarme chicos..

[xKuZz]

Aunque devolver 0 o 1 es correcto, es, al menos en mi opinión más apropiado utilizar el tipo bool que el lenguaje nos ofrece. Dicho tipo bool puede tomar dos valores: true (si es verdadero) o false (si es falso).

Vamos a tu código el error es muy simple.

Código C++:

int NumeroLetras;
cin >> NumeroLetras; // Esto implica que el número que introduzca ya sea 5, 20 o 40000 se almacena en NumeroLetras
 
....
 
bool ValidarNumeroIngresado(int NumeroLetras){
   if (NumeroLetras < 48 || NumeroLetras >57)
      return false;
   else
      return true; // Devuelvo verdadero si el int esta en el rango [49,57]
 

Tu código devolverá verdadero sin introduzco por pantalla enteros del 49 al 57 ambos inclusive, que obviamente no es lo que quieres.

¿Cómo puedes solucionarlo? Hay mil y una forma de hacerlos pero vamos a centrarnos en la más simple para este pequeño trozo de código.

cin tiene asociados unos bits de estado que se activan bajo ciertas circunstancias. Vamos a ir a una circunstancia que provocaría dicho comportamiento. Si yo ejecutase tu programa y e introduzco alguna cosa que no es un entero el bit de fail se activa. Para comprobar que si dicho bit está activado está el método cin.fail().

Nota: Tanto fail() como otros tres bits de estado son comunes para todo flujo, ya sea cin/cout o un archivo fstream.

Además por la naturaleza de tu ejemplo, podemos estar seguros de que quieres un valor estrictamente mayor que 0 y menor o igual que el tamaño de la mayor palabra. Así pues una posible solución al problema encontrado sería:

Código C++:

const int kMAXTAM=10 // Supongo que la palabra más grande que puedo usar tiene 10 letras
int NumeroLetras;
cin >> NumeroLetras;
if(cin.fail() || NumeroLetras<=0 || NumeroLetras>kMAXTAM){
   // Lo que se hace cuando no es correcto
}
else {
  // Lo que se hace cuando es correcto
}
 

[RGT]

Iniciado por xKuZz

Aunque devolver 0 o 1 es correcto, es, al menos en mi opinión más apropiado utilizar el tipo bool que el lenguaje nos ofrece. Dicho tipo bool puede tomar dos valores: true (si es verdadero) o false (si es falso).

Vamos a tu código el error es muy simple.

Código C++:

int NumeroLetras;
cin >> NumeroLetras; // Esto implica que el número que introduzca ya sea 5, 20 o 40000 se almacena en NumeroLetras
 
....
 
bool ValidarNumeroIngresado(int NumeroLetras){
   if (NumeroLetras < 48 || NumeroLetras >57)
      return false;
   else
      return true; // Devuelvo verdadero si el int esta en el rango [49,57]
 

Tu código devolverá verdadero sin introduzco por pantalla enteros del 49 al 57 ambos inclusive, que obviamente no es lo que quieres.

¿Cómo puedes solucionarlo? Hay mil y una forma de hacerlos pero vamos a centrarnos en la más simple para este pequeño trozo de código.

cin tiene asociados unos bits de estado que se activan bajo ciertas circunstancias. Vamos a ir a una circunstancia que provocaría dicho comportamiento. Si yo ejecutase tu programa y e introduzco alguna cosa que no es un entero el bit de fail se activa. Para comprobar que si dicho bit está activado está el método cin.fail().

Nota: Tanto fail() como otros tres bits de estado son comunes para todo flujo, ya sea cin/cout o un archivo fstream.

Además por la naturaleza de tu ejemplo, podemos estar seguros de que quieres un valor estrictamente mayor que 0 y menor o igual que el tamaño de la mayor palabra. Así pues una posible solución al problema encontrado sería:

Código C++:

const int kMAXTAM=10 // Supongo que la palabra más grande que puedo usar tiene 10 letras
int NumeroLetras;
cin >> NumeroLetras;
if(cin.fail() || NumeroLetras<=0 || NumeroLetras>kMAXTAM){
   // Lo que se hace cuando no es correcto
}
else {
  // Lo que se hace cuando es correcto
}
 

Excelente explicacion hermano pero no entendi lo de kMAXTAM=10, fue lo unico.,....

[aguml]

Tengo una duda al respecto. cin se que tiene fail() y good() para controlar si algo falló. Mi duda es que si introduces un entero mayor que el valor máximo permitido ¿el bit de fail estaría a true? En un depurador como ollydbg si examinas un binario y un entero se desborda se activa el Flag O ¿cin tiene algún bit para controlar eso?
Y si en vez de cin es un simple int que voy incrementando ¿como puedo saber si el int se desbordó?
Por ejemplo:

Código C++:

int a=10,b=10;
bool salir=false;
do {
   a *=b;
   b+=a;
while (salir==false);
 

Ese bucle es infinito pero si quisiera salir si a o b se desborda ¿como lo haría? No vale comparar con el valor máximo porque al desbordarse valdría siempre menos.

[eferion]

Iniciado por RGT

Excelente explicacion hermano pero no entendi lo de kMAXTAM=10, fue lo unico.,....

Sirve para indicar el número máximo que vas a admitir como válido.

¿Por qué usar una constante en vez de poner el valor "a pelo"? Porque es una buena práctica de programación.

Normalmente un valor constante se suele reutilizar varias veces en el código (por ejemplo el tamaño máximo de una matriz, o un número mágico usado para delimitar, ...

Si los valores constantes los encierras en una variable constante consigues de un plumazo varias cosas:

• El valor puede ser utilizado con facilidad en varias partes del código
• Si en el futuro ese valor cambia, únicamente tendrás que modificarlo en un sitio... esto evita muchos errores.
• Tener el valor en una constante te permite identificar qué valores están relacionados entre sí y cuales no. Esto quiere decir que no es muy útil tener, por ejemplo: const int diez = 10; y reutilizar este valor por doquier... el nombre de la constante tiene que ser representativo y no hay que reutilizar la misma constante para cosas diferentes.

Un saludo

[aguml]

Despues de quebrarme el coco un poco he conseguido dos formas de hacer lo que pedia:

Código C++:

//---------------------------------------------------------------------------
#include <iostream>
#include <cstring.h>
 
bool ObtenerEnteroMetodo1(int *valor);
int ObtenerEnteroMetodo2(int *valor);
 
int main(int argc, char* argv[])
{
   int valor;
 
   switch(ObtenerEnteroMetodo2(&valor)){
      case 0:
         std::cout << "El valor resultante es: " << valor;
         break;
      case 1:
         std::cout << "Huvo Overflow" << std::endl;
         break;
      case 2:
         std::cout << "Formato invalido para un entero" << std::endl;
         break;
   }
 
   return 0;
}
//---------------------------------------------------------------------------
 
bool ObtenerEnteroMetodo1(int *valor)
{
   bool error=false;
   std::cout<<"Introduce un valor entero: ";
   std::cin >> *valor;
 
   //Metodo 1 para comprobar overflow de entero al obtenerlo con cin
   //Este metodo no discrimina entre el fallo, o sea, si meto una cadena
   //que no puede convertir en un numero dará fallo pero no podré saber
   //que fallo dio
   if(std::cin.fail()){
      error=true;
   }
   return !error;
}
//---------------------------------------------------------------------------
 
int ObtenerEnteroMetodo2(int *valor)
{
   //Metodo 2 para comprobar overflow de entero al obtenerlo con cin
   //Creo que es el mas completo
   string cadena;
   int valorbackup;
   int error=0,negativo=false;
 
   *valor=0;
   std::cout<<"Introduce un valor entero: ";
   std::cin >> cadena;
   for(int i=0; i < cadena.length();i++){
      if(cadena[i] >='0' && cadena[i] <='9'){
         valorbackup=*valor;
         *valor*=10;
         *valor += (cadena[i]-'0');
         if(valorbackup != *valor/10){
            error=1; //Huvo overflow
            break;
         }
      }else if(i==0 && cadena[i] =='-'){
         negativo=true;
      }else{
         error=2; //Cadena con formato invalido
         break;
      }
   }
   if(negativo)
      *valor *= -1; //Convertir el numero en negativo
   return error;
}
 

Me gusta como ha quedado el metodo 2 pero si veis como mejorarlo soy todo oidos jejeje.

[eferion]

Venga, yo también quiero :)

Código C++:

enum class ConvertError
{
  NoError,
  Overflow,
  WrongFormat
};
 
ConvertError ToInt( std::istream& stream, int& value )
{
  ConvertError toReturn = ConvertError::NoError;
 
  bool negate = false;
  bool firstChar = true;
  value = 0;
  bool nextIteration = true;
  do
  {
    char c = stream.peek();
 
    if( c == EOF )
      nextIteration = false;
    else
    {
      stream.get(); // discard from the stream
 
      if( c==' ' || c=='\n' || c=='\r' || c=='\t' )
        nextIteration = false;
      else if( isdigit(c) )
      {
        int newValue = value*10+c-'0';
        if( newValue < value )
        {
          nextIteration = false;
          toReturn = ConvertError::Overflow;
        }
        value = newValue;
      }
      else
      {
        if( (c != '-' && c != '+') || !firstChar )
        {
          nextIteration = false;
          toReturn = ConvertError::WrongFormat;
        }
        else
          negate = (c=='-');
      }
    }
    firstChar = false;
  } while(nextIteration);
 
  if( negate )
    value *= -1;
 
  return toReturn;
}
 

[aguml]

guauuu. ¿y eso como se usa? ¿puedes poner un ejemplo donde pueda compilarlo para ver como funciona y depurarlo a ver si me entero?
Creo que entiendo lo que hace tu funcion pero lo que haces de enum class no soy capaz de que compile.
Edito:
Tuve que modificar tu codigo porque eso que pones de enum class mi compilador no se lo traga y supongo que o bien el compilador que uso es anterior a c++11 que creo que es donde se metio eso segun he leido, o bien no es estandard o yo que se jajaja.
Asi lo he dejado:

Código C++:

//---------------------------------------------------------------------------
#include <iostream>
#include <sstream>
 
using namespace std;
 
enum ConvertError
{
  NoError,
  Overflow,
  WrongFormat
};
//---------------------------------------------------------------------------
 
ConvertError ToInt( std::istream& stream, int& value )
{
  ConvertError toReturn = NoError;
 
  bool negate = false;
  bool firstChar = true;
  value = 0;
  bool nextIteration = true;
  do
  {
    char c = stream.peek();
 
    if( c == EOF )
      nextIteration = false;
    else
    {
      stream.get(); // discard from the stream
 
      if( c==' ' || c=='\n' || c=='\r' || c=='\t' )
        nextIteration = false;
      else if( isdigit(c) )
      {
        int newValue = value*10+c-'0';
        if( newValue < value )
        {
          nextIteration = false;
          toReturn = Overflow;
        }
        value = newValue;
      }
      else
      {
        if( (c != '-' && c != '+') || !firstChar )
        {
          nextIteration = false;
          toReturn = WrongFormat;
        }
        else
          negate = (c=='-');
      }
    }
    firstChar = false;
  } while(nextIteration);
 
  if( negate )
    value *= -1;
 
  return toReturn;
}
//---------------------------------------------------------------------------
 
int main(int argc, char* argv[])
{
   stringstream stream;
   string aux;
   int valor;
   cin >> aux;
   stream <<aux;
   switch(ToInt(stream,valor)){
      case 0:
         cout<<"El valor es: "<<valor<<endl;
         break;
      case 1:
         cout<<"Huvo overflow"<<endl;
         break;
      case 2:
         cout<<"Formato incorrecto"<<endl;
         break;
   }
   return 0;
}
//---------------------------------------------------------------------------
 

Por cierto no sabia que un enum se podia usar como tipo de retorno.
Otra cosa ¿que virtudes tiene tu codigo con respecto al mio?
Y si quieres echar un vistazo a como hago para ejecutar tu funcion y me dices si es correcto o hay un camino mas corto para no tener que usar stringstream...

[xKuZz]

No tienes porqué utilizar stringstream para nada. Al final te dejo un ejemplo.

La principal ventaja que tiene el código de eferion es que extremadamente legible, cualquier persona con un poco de idea de inglés y el lenguaje es capaz de comprender al instante lo que su código hace.

Cómo usarlo:

Código C++:

int main()
{
   int valor;
   switch(ToInt(cin ,valor)){
      case NoError:
         cout<<"El valor es: "<<valor<<endl;
         break;
      case Overflow:
         cout<<"Hubo overflow"<<endl;
         break;
      case WrongFormat:
         cout<<"Formato incorrecto"<<endl;
         break;
   }
 
}
 

[aguml]

¿Seguro que eso funciona así? Lo digo porque usas cin como parámetro pero no veo que uses ni operador de sobrecarga, ni getline, ni nada. ¿que se supone que va a leer en la función ?

[eferion]

Iniciado por aguml

¿Seguro que eso funciona así? Lo digo porque usas cin como parámetro pero no veo que uses ni operador de sobrecarga, ni getline, ni nada. ¿que se supone que va a leer en la función ?

La función recibe como parámetro un istream, que es el padre de todos los mecanismos de entrada ofrecidos por la STL. Esto quiere decir que puedes usarlo tanto para leer un dato de un fichero como del teclado.

Funciona porque en C++ existe el polimorfismo, que es lo que permite gestionar cualquier entrada sin importar su tipo concreto.

Por cierto, como comentabas en el mensaje anterior, efectivamente el código que hice esta hecho en C++11. Pero si quitas el "class" del enum debería compilar perfectamente en versiones anteriores de C++.

Un saludo.

[aguml]

Ok, entonces con lo que pone xKuZz se quedaría esperando la entrada del teclado siempre y cuando no haya datos ya en el ¿no? Igual que hace cin con getline, o get, o el operador de sobrecarga ¿no?
Muy interesante.
Por cierto estoy liado ahora con el polimorfismo y la herencia y ganas de llorar tengo jajaja. Es complejo tela.

[eferion]

Iniciado por aguml

Ok, entonces con lo que pone xKuZz se quedaría esperando la entrada del teclado siempre y cuando no haya datos ya en el ¿no?

Exacto.

Iniciado por aguml

Igual que hace cin con getline, o get, o el operador de sobrecarga ¿no?

correcto.

Iniciado por aguml

Por cierto estoy liado ahora con el polimorfismo y la herencia y ganas de llorar tengo jajaja. Es complejo tela.

El polimorfismo no es más que una característica de abstracción... su uso es, mayormente, poder utilizar una lista compuesta de objetos de diferentes clases usando para ello una clase padre común.

La herencia tampoco es demasiado complicada si no te dedicas a putearte... intenta diseñar las cosas siempre con herencia simple y procura que, de necesitar herencia compuesta, ésta se componga de interfaces (clases virtuales puras) y, como mucho, de una clase no virtual.

Lo más complicado de la herencia es saber aplicarla correctamente. No es lo mismo "A es B" (herencia) que "A contiene B" (no herencia) o "A usa B" (no herencia). Además la programación añade esa capa de intangencia que a la gente le cuesta muchísimo asimilar, dicho en cristiano. Un objeto no tiene que representar un elemento de la vida real sino más bien un concepto. El tener una clase "Coche" con 4 objetos de clase "Rueda" no tiene por qué ser necesariamente el mejor diseño. No se si me explico. Pues con la herencia pasa exactamente lo mismo... muchas veces la gente confunde una composición con una herencia y un exceso de herencia es algo bastante malo, ya que te obliga a arrastrar mucha información que no necesitas para nada... pero como la estás arrastrando también tienes que estar pendiente de ella.

Un saludo.