Foro de elhacker.net

int x;

scanf( "%d", &x);

int x;

scanf( "%d", &x);

#include <stdio.h>
 
int main(){
  int i,numero,flag=0;
  char num [20];
  do{
    flag=0;
    printf ("\nIntroduzca un numero entero:");
    fflush(stdout);
    scanf ("%s",num);
    for (i=0;num[i];i++){
      if (num[i]<'0' || num[i]>'9'){
        flag=1;
      }
    }
 
  }while (flag!=0);
  numero=atoi(num);
  printf("\nnumero= %d\n",numero);
  return 0;
}
 

#include <stdio.h>
 
int main(){
  int numero;
  printf ("\nIntroduzca un numero entero:");
  fflush(stdout);
  scanf ("%s",numero);
  printf("\nnumero= %d\n",numero);
  return 0;
}
 

test1.c: In function ‘main’:
test1.c:18: error: ‘x’ undeclared (first use in this function)
test1.c:18: error: (Each undeclared identifier is reported only once
test1.c:18: error: for each function it appears in.)

/* No cero si la cadena apuntada por s representa un número real decimal.
	La cadena deberá contener sólo los caracteres "+-0123456789. ". 
 
	- El carácter de punto decimal es el punto '.', es opcional y sólo puede aparecer 
	  una vez en la cadena.
	- El carácter de signo '+' o '-' es opcional, sólo puede aparecer una vez y como 
	  primer carácter no blanco de la cadena.
	- Se admiten secuencias de espacios ' ' al principio o al final de la cadena, pero
	  son ignoradas. No se admiten espacios en el medio de la cadena.
 
	Esta definición es acorde con la configuración regional estándar en Español, pero
	pudiera adaptarse para la configuración en Inglés (la coma ',' antes que el punto '.').
 
	No admitimos en esta implementación representaciones en punto flotante con mantisa y
	exponente, sólo mantisa.
*/
int isnumeric(const char *s) {
 
	const char *allowed_chars = "0123456789.";		/* caracteres permitidos */
	char c;
	int i, j, N;
	bool exists_point = false, exists_sign = false;
	bool pre_space = false, post_space = false;
 
	N = strlen(allow_chars);
	for (i = 0; i < INT_MAX && s[i]!='\0'; i++) {
		c = s[i];
 
		// sólo se admite un carácter opcional '+' ó '-' y como primer
		// no blanco de la cadena
		if (c == '+' || c == '-') {
			if (exists_sign == true) 
				return 0;	
			else {
				exists_sign = 1;
				if (i>0)
					if (s[i-1] != ' ') return 0;
			}
			continue;
		}
 
		if (c == ' ') {
			if (pre_space == false) pre_space = 1;
			if (i > 0 && s[i-1] != ' ') post_space = 1;
			continue;
		}
		if (post_space == true && c != ' ') return 0;
 
		// buscando caracteres permitidos
		for (j=0; j<N; j++)
			if (c == allowed_chars[j]) break;
		if (j == N) return 0;		
 
		// no puede haber más de un carácter '.'
		if (c == '.') {
			if (exists_point == 1) 
				return 0;			
			else
				exists_point = 1;
		}
	}
 
	// si no detecta error, sale con valor 1
	return 1;
}

enum type{
    type_signed = 1,
    type_bool = 2,
    type_int = 4,
    type_short = 8,
    type_float = 16,
    type_double = 32,
    type_char = 64
    /* ... */
}
 
int typeOf(string s){
    /** Esto retornará un entero compuesto de los números que pueda ser.
          Si es "12", por ejemplo, puede ser short, int, float, double y char. Entonces, retornaría: 4+8+16+32+64. (Puede ser más tipos, pero aun estoy empezando el enum jaja **/
}

if(typeOf(str)&type_double) double d = parse<double>(str);

enum type{
    /**    SIGNED TYPES    **/
    type_bool     = 0b0000000000000001,
    type_char     = 0b0000000000000010,
    type_short    = 0b0000000000000100,
    type_int      = 0b0000000000001000,
    type_llong    = 0b0000000000010000,
    type_float    = 0b0000000000100000,
    type_double   = 0b0000000001000000,
    type_ldouble  = 0b0000000010000000,
 
    /**    UNSIGNED TYPES    **/
    type_ubool    = 0b0000000100000000,
    type_uchar    = 0b0000001000000000,
    type_ushort   = 0b0000010000000000,
    type_uint     = 0b0000100000000000,
    type_ullong   = 0b0001000000000000,
    type_ufloat   = 0b0010000000000000,
    type_udouble  = 0b0100000000000000,
    type_uldouble = 0b1000000000000000,
 
    /**    OTHER    **/
    type_signed   = 0b0000000011111111,
    type_unsigned = 0b1111111100000000,
    type_all      = 0b1111111111111111
};

#include <iostream>
 
using namespace std;
 
enum type{
    /**    TYPES    **/
    type_bool     = 0b000000000001,
    type_char     = 0b000000000010,
    type_uchar    = 0b000000000100,
    type_short    = 0b000000001000,
    type_ushort   = 0b000000010000,
    type_int      = 0b000000100000,
    type_uint     = 0b000001000000,
    type_llong    = 0b000010000000,
    type_ullong   = 0b000100000000,
    type_float    = 0b001000000000,
    type_double   = 0b010000000000,
    type_ldouble  = 0b100000000000,
 
    /**    OTHER    **/
    type_signed   = 0b111010101011,
    type_unsigned = 0b000101010100,
    type_all      = 0b111111111111
};
 
bool allNumeric(string s){
    for(int i=0; i<s.size(); i++)
        if(s[i]<48 || s[i]>57)
        return false;
    return true;
}
 
bool minorEqual(string a, string b){
    if(a.size()<b.size()) return true;
    if(a.size()>b.size()) return false;
    if(a==b) return true;
    for(int i=0; i<a.size(); i++)
        if(a[i]<b[i]) return true;
        else if(a[i]>b[i]) return false;
    return true;
}
 
int typeOf(string s){
    if(s=="") return 0;
    int type = 0;
    bool sign = false;
    /** BOOL **/
    if((s.size()==1 && (s[0]=='0'||s[0]=='1'))||(s.size()==4 &&s.substr(0, 4)=="true")||(s.size()==5 &&s.substr(0, 5)=="false"))
        type+=type_bool;
 
    /** CHAR && UCHAR **/
    if(s.size()==1)
        type+=type_char+type_uchar;
    else{
        if(s[0]=='-')
            sign=true;
        if(s.size()<4+sign && allNumeric(s.substr(sign, s.size()))){
            if(sign){
                if(minorEqual(s.substr(1, s.size()), "128"))
                    type+=type_char;
            }else{
                if(minorEqual(s.substr(0, s.size()), "127"))
                    type+=type_char;
                if(minorEqual(s.substr(0, s.size()), "255"))
                    type+=type_uchar;
            }
        }
    }
 
    /** SHORT && USHORT **/
    if(s[0]=='-')
        sign=true;
    if(allNumeric(s.substr(sign, s.size()))){
        if(sign){
            if(minorEqual(s.substr(1, s.size()), "32768"))
                type+=type_short;
        }else{
            if(minorEqual(s.substr(0, s.size()), "32767"))
                type+=type_short;
            if(minorEqual(s.substr(0, s.size()), "65535"))
                type+=type_ushort;
        }
    }
 
    /** INT && UINT **/
    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"))
                type+=type_int;
            if(minorEqual(s.substr(0, s.size()), "4294967295"))
                type+=type_uint;
        }
    }
 
    /** LONG && ULONG **/
    if(s[0]=='-')
        sign=true;
    if(allNumeric(s.substr(sign, s.size()))){
        if(sign){
            if(minorEqual(s.substr(1, s.size()), "9223372036854775808"))
                type+=type_llong;
        }else{
            if(minorEqual(s.substr(0, s.size()), "9223372036854775807"))
                type+=type_llong;
            if(minorEqual(s.substr(0, s.size()), "18446744073709551615"))
                type+=type_ullong;
        }
    }
    double b=atof(s.c_str());
    float a=(float)b;
    bool is=false;
    if(b==0.0 && (s=="0"||s=="0.0")){
        type+=type_float+type_double;
    }else if(b!=0.0){
        type+=type_double;
        if(a==b)
            type+=type_float;
    }
    return type;
}
 
int main(){
    string s;
    getline(cin, s);
    if(typeOf(s)&type_int)
        cout << "Se puede transformar en un entero (signed)." << endl;
    cin.get();
    return 0;
}

int potencia(int n, int b){
   int temp=1;
   for(int i=0;i<b;i++) temp=temp*n;
   return temp;
}
 
int parseString(string s){
 string a;
 int num = 0;
 for(int i=s.length()-1;i>=0;i--){
  if(!((int)s[i]>=48 && (int)s[i]<=57)) return 0;
  num+=((int)s[i]-48)*(potencia(10, s.length()-i-1));
 }
 return num;
}

int x;

scanf( "%d", &x);

a = 111         // Valor numerico 111
b = 222         // Valor numerico 222
Imprimir a + b  // Imprime 333

// ...

a = "111"       // La cadena 111
b = "222"       // La cadena 222
Imprimir a + b  // Imprime 111222

do {
   puts("Introduzca un numero entero:");
   scanf("%s", num);
 
   for (i = 0; isdigit(num[i]); i++)
      ;
}while (num[i] != '\0');

test1.c: In function ‘main’:
test1.c:18: error: ‘x’ undeclared (first use in this function)
test1.c:18: error: (Each undeclared identifier is reported only once
test1.c:18: error: for each function it appears in.)

    do {
      puts("Introduzca un numero entero:");
      scanf("%s", num);
 
      for (i = 0; isdigit(num[i]); i++)
         ;
    }while (num[i] != '\0');