Mensajes

No entiendo lo que haces.

A mi compilando tu codigo me da esto:

# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # .
. # # # . . . # # # # #

Cual es el resultado esperado? No veo ningun camino en el laberinto

Hola,

Un equipo que no reconozco apareció en la vista de equipos en red, una cosa asi;

Red
-MIEQUIPO-PC
-MIOTROEQUIPO-PC
-EQUIPODESCONOCIDO-PC

Al darle me dijo que ese equipo no se podia encontrar. He buscado en el registro de sucesos pero no encuentro nada sobre los equipos previamentes conectados a la red, ni siquiera los mios.

¿Hay algun log donde ver el historial de equipos conectados en la red LAN en windows 7?

¿Cuando un ordenador intenta conectarse y no sabe la clave, llega a aparecer en el explorador de archivos en la sección Red?

No tengo idea de como hacerlo pero como pasan los dias y no sale la solucion; quizas podrias ver si lo puedes hacer con threads. Solo se que con eso se crean varios "hilos" para que el ordenador haga varias cosas a la vez.

Otra opcion que se me ocurre pasa por no usar las dos a la vez, sino sacar el valor de la primera, guardarlo en variable, y operar con la segunda base de datos y la variable de la primera.

[char]

Tal como te dice hotcake has de usar una variable tipo string para el nombre.

El codigo que te pongo mas abajo funciona compilandolo en notepad++ con MinGW y usando estos paramatros:

//Guardar el archivo actual
NPP_SAVE

//Borrar el exe anterior
cmd /c del /Q "$(CURRENT_DIRECTORY)\$(NAME_PART).exe"

//Compila (aqui debes indicar la ruta en donde se encuentra tú compilador g++)
C:\MinGW\bin\g++.exe "$(FULL_CURRENT_PATH)" -o $(NAME_PART)

//Ejecutamos el programa.
$(CURRENT_DIRECTORY)\$(NAME_PART).exe

char solo guarda un caracter que es un numero de 0 a 255. char se puede usar para guardar cadenas si lo ponemos cono array char[20]

Lo que hacemos es declarar name como string, que es un tipo especial de dato para guardar cadenas de caracteres:
He añadido ademas la impresion de la variable name para probar su funcionamiento.

Código (cpp) [Seleccionar] Expandir

#include <iostream>

//PROGRAMA QUE DEVUELVE UN VALOR "PISO" SEGUN LA EDAD INGRESADA

using namespace std;

main()
{
       string name;
       int edad;

       cout<<"Introduzca su nombre :";
cin>>name;
       cout<<"Digite su edad :";
cin>>edad;

       cout<<"\n"<<name<<" VA AL ";

if(edad>=0 && edad<=9)cout<<"PISO 0";
else if(edad>=10 && edad<=19)cout<<"PISO 1";
else if(edad>=20 && edad<=29)cout<<"PISO 2";
else if(edad>=30 && edad<=39)cout<<"PISO 3";
else if(edad>=40 && edad<=49)cout<<"PISO 4";
else if(edad>=50 && edad<=59)cout<<"PISO 5";
else if(edad>=60 && edad<=69)cout<<"PISO 6";
else if(edad>=70 && edad<=79)cout<<"PISO 7";
else
cout<<"\nERROR"<<endl;

cout<<endl;
}

El uso de cin.ignore lo desconozco ya que he solido usar simpre printf y scanf

Declarar main como int y devolver un valor con return, parece que depende del compilador.

Y tambien te informo ya de paso de que no estas usando ningun bucle en ese codigo.

Y en mi caso que el sistema es de 64 bits? realmente se puede manejar un bloque de 32 bits?

Que hace, optimizar y guardar en memoria dos de 32 juntos, o que?

Funciona lo de dividir por cero para comparar con el infinito!!

Dejando los decimales aparte, que veo que tienen tela. me quedan unas dudas.

int, long, y long int es lo mismo? o tengo algo mal?

infinito, que bien!! infinito es mayor que cero!! asi que no acababa nunca XD

Hay alguna manera de saber cuando se ha desbordado un double y un float? Es decir, no quiero usar una constante para ver si se llega al final. Quiero desbordar el tipo detectarlo, e imprimir su valor mayor y menor, igual que hago en los tipos mas pequeños.

No, no termina. Nunca sale lo de pulse una tecla para continuar.

Edito el post inicial ya que unsigned long int y unsigned int, fallaban porque ponia %i en vez de %u

En cuanto a los dos ultimos tipos double y float aunque comente el printf se quedan atascados supuestamente calculando y consumiendo el 25% del procesador cuatro nucleos.

Que hago mal para que no termine de multiplicarse por dos. double y float no se resetean como los otros tipos cuando se desbordan?

Vale ya he visto que tengo mal el formato en los printf. Voy a revisarlo

Hola,

Estoy haciendo un programa para comprobar el tamaño y signo admitido por las variables en c y su funcionalidad en cada version de windows y arquitectura. Todo empezo porque cuando intento usar por ejemplo double se queda calculando indefinidamente.

Este es el programa:

Código (cpp) [Seleccionar] Expandir


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

void main(){
char tipo_char=1, tipo_char_max=1;                                                  //          -128 a 128
unsigned char tipo_unsigned_char=1, tipo_unsigned_char_max=1;                       //             0 a 256
short int tipo_short_int=1, tipo_short_int_max=1;                                   //        -32768 a 32767
unsigned short int tipo_unsigned_short_int=1, tipo_unsigned_short_int_max=1;        //             0 a 65 535
long int tipo_long_int=1, tipo_long_int_max=1;                                      //-2 147 483 648 a 2 147 483 647
unsigned long int tipo_unsigned_long_int=1, tipo_unsigned_long_int_max=1;           //             0 a 4 294 967 295
int tipo_int=1, tipo_int_max=1;                                                     //-2 147 483 648 a 2 147 483 647
unsigned int tipo_unsigned_int=1, tipo_unsigned_int_max=1;                          //             0 a 4 294 967 295
double tipo_double=1, tipo_double_max=1;                                            //           18 446 744 073 709 551 616
float tipo_float=1, tipo_float_max=1;                                               //          18 446 744 073 709 551 616

while(tipo_char>0){
tipo_char_max=tipo_char+(tipo_char-1);
tipo_char=tipo_char*2;
//printf("La variable char admite como maximo: %i \n\n",tipo_char);
}
printf("La variable char admite numeros entre: %i y %i \n\n",tipo_char,tipo_char_max);

while(tipo_unsigned_char>0){
tipo_unsigned_char_max=tipo_unsigned_char+(tipo_unsigned_char-1);
tipo_unsigned_char=tipo_unsigned_char*2;
}
printf("La variable unsigned char admite numeros entre: %i y %i \n\n",tipo_unsigned_char,tipo_unsigned_char_max);

while(tipo_short_int>0){
tipo_short_int_max=tipo_short_int+(tipo_short_int-1);
tipo_short_int=tipo_short_int*2;
}
printf("La variable short int admite numeros entre: %i y %i \n\n",tipo_short_int,tipo_short_int_max);

while(tipo_unsigned_short_int>0){
tipo_unsigned_short_int_max=tipo_unsigned_short_int+(tipo_unsigned_short_int-1);
tipo_unsigned_short_int=tipo_unsigned_short_int*2;
//printf("La variable admite como maximo: %i \n\n",tipo_unsigned_short_int);
}
printf("La variable unsigned short int admite numeros entre: %i y %i \n\n",tipo_unsigned_short_int,tipo_unsigned_short_int_max);

while(tipo_long_int>0){
tipo_long_int_max=tipo_long_int+(tipo_long_int-1);
tipo_long_int=tipo_long_int*2;
//printf("La variable admite como maximo: %i \n\n",tipo_long_int);
}
printf("La variable long int admite numeros entre: %i y %i \n\n",tipo_long_int,tipo_long_int_max);

while(tipo_unsigned_long_int>0){
tipo_unsigned_long_int_max=tipo_unsigned_long_int+(tipo_unsigned_long_int-1);
tipo_unsigned_long_int=tipo_unsigned_long_int*2;
//printf("La variable admite como maximo: %i \n\n",tipo_unsigned_long_int);
}
printf("La variable unsigned long int admite numeros entre: %u y %u \n\n",tipo_unsigned_long_int,tipo_unsigned_long_int_max);

while(tipo_int>0){
tipo_int_max=tipo_int+(tipo_int-1);
tipo_int=tipo_int*2;
//printf("La variable admite como maximo: %i \n\n",tipo_long_int);
}
printf("La variable int admite numeros entre: %i y %i \n\n",tipo_int,tipo_int_max);

while(tipo_unsigned_int>0){
tipo_unsigned_int_max=tipo_unsigned_int+(tipo_unsigned_int-1);
tipo_unsigned_int=tipo_unsigned_int*2;
//printf("La variable admite como maximo: %i \n\n",tipo_unsigned_int);
}
printf("La variable unsigned int admite numeros entre: %u y %u \n\n",tipo_unsigned_int,tipo_unsigned_int_max);

while(tipo_float>0){
tipo_float_max=tipo_float+(tipo_float-1);
tipo_float=tipo_float*2;
//printf("La variable admite como maximo: %i \n\n",tipo_float);
}
//printf("La variable float admite numeros entre: %4.2f y %4.2f \n\n",tipo_float,tipo_float_max);

while(tipo_double>0){
tipo_double_max=tipo_double+(tipo_double-1);
tipo_double=tipo_double*2;
//printf("La variable admite como maximo: %i \n\n",tipo_double);
}
//tipo_double=18446744073709551616;
//printf("La variable double admite numeros entre: %4.2f y %4.2f \n\n",tipo_double,tipo_double_max);



system("pause");


}



Y este el resultado:

La variable char admite numeros entre: -128 y 127

La variable unsigned char admite numeros entre: 0 y 255

La variable short int admite numeros entre: -32768 y 32767

La variable unsigned short int admite numeros entre: 0 y 65535

La variable long int admite numeros entre: -2147483648 y 2147483647

La variable unsigned long int admite numeros entre: 0 y 4294967295

La variable int admite numeros entre: -2147483648 y 2147483647

La variable unsigned int admite numeros entre: 0 y 4294967295

_

Y tanto el tipo double como float se queda ahi trabajando pero no termina ni en varios minutos.

El ordenador es un i5, 8GB de RAM. El SO Win7 64bits. El compilador minGW64 gcc.exe. El editor Notepad++.

Que puede fallar para que double y float no me den el resultado esperado?