Recibir int seguro

[Yoel Alejandro]

Una recomendación a ivance96. Para que el código sea más portable, recordemos que los tipos enteros no tienen una longitud rígidamente definida, por ejemplo en algunas máquinas (antiguas) los enteros son de 16bits, y en otras de 32bits. Si mal no recuerdo, la norma indica que la longitud de int debe estar entre la longitud de short y la de long, pero la elección entre ambos depende de la implementación. Debiendo ser la longitud de short de al menos 16 bits, y la de long de al menos 32 bits. Así que por ejemplo una implementación en particular (quizá en el futuro, para una máquina potente) pudiera tener short de 32 bits, int de 64 bits y long de 64 bits.

La biblioteca <limits.h> define los máximos posibles para los distintos tipos aritméticos según la puesta en práctica. Por ejemplo, CHAR_MAX, SHRT_MAX, UINT_MAX define los máximos de char, short int y unsigned int respectivamente, y son valores que dependen de la implementación de C en tu máquina particular. Así que el programa podría quedar algo así como:

Código (cpp) [Seleccionar] Expandir


/** INT && UINT **/
if(s[0]=='-')
sign=true;
if ( allNumeric(s.substr(sign, s.size()))) {
if(sign) {
    if ( atoi(s.substr(1, s.size())) <= INT_MAX  )
type+=type_int;
}else{
if ( atoi(s.substr(0, s.size())) <= INT_MAX )
type+=type_int;
if ( atoi(s.substr(0, s.size())) <= UINT_MAX)
type+=type_uint;
}
}

el cual es transportable sin problemas de una máquina a otra.

[leosansan]

Lo de un número fijo era por lo de las tarjetas de crédito y cosas así. Como en este código, sencillo pero muy funcional ... y sólo admite un número determinado de caracteres, si son menos  espera hasta que se complete y no da opción de más:

Código (cpp) [Seleccionar] Expandir


/*Crear un programa que pida al usuario su contraseña (numérica).
Deberá terminar cuando introduzca como contraseña el número
5879, pero
volvérsela a pedir teniendo cuatro intentos.*/
#include <stdio.h>
#include <stdlib.h>

int main( void )
{
    char clave [5];
    int i,clave_num,intentos=0,DIGITOS=4;
    do
    {
        printf ("\n\n\n\Presione una tecla para continuar: ");
        fflush (stdout);
        getch ();
        system ("cls");
        fflush (stdout);
        printf ("\n\n\n   INTRODUZCA LA CLAVE  entera (cuatro digitos) \n\n\n");
        printf ("Teclea la clave (1122 par salir) y presione enter para salir: ");
        fflush (stdout);
        for (i=0;i<DIGITOS;i++){
            clave [i] =getch();
            printf("*");
            fflush (stdout);
        }
    clave [4] ='\0';
    printf ("\n\n\t\t\tLA CLAVE INTRODUCIDA ES :%s",clave );
    fflush (stdout);
    printf ("\n\n\t\t\tLA CLAVE EN ASCII es  : ");
    fflush (stdout);
    for (i=0;i<4;i++){
                printf ("%d - ",clave[i] );
                fflush (stdout);
            }

    intentos++;
    clave_num = atoi (clave);
    printf ("%d \n",clave_num);
    if (intentos==3){
            printf ("\n\n\t\tMe quedo con la tarjeta,,AGURRRRRRRRRRR\n\n");
            exit (0) ;
        }
    }
    while (clave_num!=5879);
    printf ("\n\n\n\HASTA OTRA OCASION\n\n\n");
    return 0;
}

Como ves hay más formas de limitar el número de caracteres que los expuestos anteriormente. Este en particular el anterior "me llena", nada de tener que limpiar buffer ni cosas por el estilo.

Y perdón por el uso de getch() pero en el estándar de C no hay ninguna función similar, a no ser que se recurra a getchar() pero con una rápida limpieza de pantalla y aún así se pierden los otros datos impresos.

A mí personalmente el que fgets "meta" un retorno de carro en las cadenas me da un no sé qué .......

Y por cierto, aunque es otro tema, te he echado de menos en el hilo de los rombos. Está bastante animado y creo que aún no se ha acabado. Yo al menos me guardo un as en la manga .... y en C++ para variar.[/size]

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

[ivancea96]

Una recomendación a ivance96. Para que el código sea más portable, recordemos que los tipos enteros no tienen una longitud rígidamente definida, por ejemplo en algunas máquinas (antiguas) los enteros son de 16bits, y en otras de 32bits. Si mal no recuerdo, la norma indica que la longitud de int debe estar entre la longitud de short y la de long, pero la elección entre ambos depende de la implementación. Debiendo ser la longitud de short de al menos 16 bits, y la de long de al menos 32 bits. Así que por ejemplo una implementación en particular (quizá en el futuro, para una máquina potente) pudiera tener short de 32 bits, int de 64 bits y long de 64 bits.

La biblioteca <limits.h> define los máximos posibles para los distintos tipos aritméticos según la puesta en práctica. Por ejemplo, CHAR_MAX, SHRT_MAX, UINT_MAX define los máximos de char, short int y unsigned int respectivamente, y son valores que dependen de la implementación de C en tu máquina particular. Así que el programa podría quedar algo así como:

Código (cpp) [Seleccionar] Expandir


/** INT && UINT **/
if(s[0]=='-')
sign=true;
if ( allNumeric(s.substr(sign, s.size()))) {
if(sign) {
    if ( atoi(s.substr(1, s.size())) <= INT_MAX  )
type+=type_int;
}else{
if ( atoi(s.substr(0, s.size())) <= INT_MAX )
type+=type_int;
if ( atoi(s.substr(0, s.size())) <= UINT_MAX)
type+=type_uint;
}
}

el cual es transportable sin problemas de una máquina a otra.

Si, bueno. Salvo en el float y el double, que era un terrible follón traducirlo de char* a float/double, en las otras comprobaciones lo intentaba hacer sin las funciones atoi y parecidas.

[patilanz]

Hola con la ayuda de sus codigos he hecho esto:

Código (cpp) [Seleccionar] Expandir

#include "stdafx.h"
#include <stdlib.h>
#include <cctype>
#include "firstTest.hpp"


int getInt(char *msg,int max,int min){
char *str=new char[max+1];
do{
fflush(stdout);
printf("%s",msg);
fgets(str,max+1,stdin);
int i=-1;
bool clean=true;
while(str[++i]!='\0'){
if(str[i]=='\n'){
clean=false;
str[i]='\0';
}
}
if(clean)getchar();
str=outFirstSpace(str);
printf("\n");


}while(*str=='\0' || !isInt(str) || getLength(str)<min);
//while(getchar()!='\n');
return atoi(str);
}

char * outFirstSpace(char *str){
int length=getLength(str);
while(*str==' ')str++;
return str;
}

bool isInt(char const * const str){
int length=getLength(str);
for(int i=0;i<length;i++){
if(!isdigit(str[i])){
return false;
}
}
return true;
}

int getLength(const char * str){
int l=0;
while(*(str++)!='\0')l++;
return l;
}


Hay un problema que si se insertan mas caracteres de los que pide fgets() luego repite el printf("%s",msg) muchas veces. No se que pasa pero no he conseguido limpiar el buffer. Sabéis como?


@Edit: Acabo de crear otro con iostream en c++

Código (cpp) [Seleccionar] Expandir

#include "stdafx.h"
#include "secondTest.hpp"


int getInt(string msg,int max,int min){
string str;
do{
cout << msg;
cin.clear();
cin >> str;
}while(!isInt(str) || str.size()>max || str.size()<min);
return atoi(str.data());
}

bool isInt(string str){
for(size_t i=0;i<str.size();i++){
if(!isdigit(str[i]))
return false;
}
return true;
}

Este no tiene problemas o por lo menos no los he descubierto.

Saludos

[Yoel Alejandro]

Leo, tu programa es ideal para el caso de una clave numérica con una cantidad exacta de dígitos, además obliga al usuario sobre meter exactamente esa cantidad.

Y respecto a los rombos, ....... tranquilo jaja que ya voy a aparecer con una idea que he estado pensando y espero sorprendente  (tanto como las de todos)

[rir3760]

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

En ese caso nada impide verificar el resto del stream con una lectura adicional, las funciones eof/get, etc. Por ejemplo:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

#include <string>
using std::string;
using std::getline;

#include <sstream>
using std::istringstream;

int main()
{
   bool ok = false;
   int num;
   
   do {
      cout << "Introduce un numero: ";
      string linea;
      getline(cin, linea);
   
      istringstream is(linea);
      char ch;
      if (is >> num && !(is >> ch))
         ok = true;
      else
         cout << "Entrada no valida" << endl;
   }while (!ok);
   
   cout << "num == " << num << endl;
   
   return 0;
}

----

La biblioteca <limits.h> define los máximos posibles para los distintos tipos aritméticos según la puesta en práctica. Por ejemplo, CHAR_MAX, SHRT_MAX, UINT_MAX define los máximos de char, short int y unsigned int respectivamente, y son valores que dependen de la implementación de C en tu máquina particular. Así que el programa podría quedar algo así como:

Código (cpp) [Seleccionar] Expandir

/** INT && UINT **/
if(s[0]=='-')
sign=true;
if ( allNumeric(s.substr(sign, s.size()))) {
if(sign) {
    if ( atoi(s.substr(1, s.size())) <= INT_MAX  )
type+=type_int;
}else{
if ( atoi(s.substr(0, s.size())) <= INT_MAX )
type+=type_int;
if ( atoi(s.substr(0, s.size())) <= UINT_MAX)
type+=type_uint;
}
}

Un problema con ese fragmento es el uso de atoi, por razones obvias su valor de retorno no puede ser mayor a INT_MAX. Para conocer si un numero esta fuera del rango valido para un tipo entero se deben utilizar las funciones strtol, strtoll (C++11), etc. dependiendo del caso (y del modo de compilación).

Un saludo