elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Mensajes
Páginas: 1 2 3 4 [5] 6 7 8
41  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 26 Septiembre 2016, 18:18 pm
Joer, no vi el cambio de pagina.

Muchas gracias. Intente usar ese tipo de declaracion pero no me funcionó. Volveré a probar.

El programa quedo asi:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. void main(){
  6. char tipo_char=1, tipo_char_max=1;                                                  //          -128 a 128
  7. unsigned char tipo_unsigned_char=1, tipo_unsigned_char_max=1;                       //             0 a 256
  8. short int tipo_short_int=1, tipo_short_int_max=1;                                   //        -32768 a 32767
  9. unsigned short int tipo_unsigned_short_int=1, tipo_unsigned_short_int_max=1;        //             0 a 65 535
  10. int tipo_int=1, tipo_int_max=1;                                                     //-2 147 483 648 a 2 147 483 647
  11. long tipo_long=1, tipo_long_max=1;                                                  //-2 147 483 648 a 2 147 483 647
  12. long int tipo_long_int=1, tipo_long_int_max=1;                                      //-2 147 483 648 a 2 147 483 647
  13. unsigned int tipo_unsigned_int=1, tipo_unsigned_int_max=1;                          //             0 a 4 294 967 295
  14. unsigned long tipo_unsigned_long=1, tipo_unsigned_long_max=1;                       //             0 a 4 294 967 295
  15. unsigned long int tipo_unsigned_long_int=1, tipo_unsigned_long_int_max=1;           //             0 a 4 294 967 295
  16. long long tipo_long_long=1, tipo_long_long_max=1;                            // -9223372036854775808 a  9223372036854775807
  17. unsigned long long tipo_unsigned_long_long=1, tipo_unsigned_long_long_max=1; //                    0 a 18 446 744 073 709 551 616
  18.  
  19. int bits=1;
  20.  
  21. while(tipo_char>0){
  22. tipo_char_max=tipo_char+(tipo_char-1);
  23. tipo_char=tipo_char*2;
  24. //printf("char admite como maximo: %i \n\n",tipo_char);
  25. bits++;
  26. }
  27. printf("char ................. %ibits de                    %i a                  %i \n\n",bits,tipo_char,tipo_char_max);
  28. bits=0;
  29. while(tipo_unsigned_char>0){
  30. tipo_unsigned_char_max=tipo_unsigned_char+(tipo_unsigned_char-1);
  31. tipo_unsigned_char=tipo_unsigned_char*2;
  32. bits++;
  33. }
  34. printf("unsigned char ........ %ibits .. de                    %i a                  %i \n\n",bits,tipo_unsigned_char,tipo_unsigned_char_max);
  35. bits=1;
  36. while(tipo_short_int>0){
  37. tipo_short_int_max=tipo_short_int+(tipo_short_int-1);
  38. tipo_short_int=tipo_short_int*2;
  39. bits++;
  40. }
  41. printf("short int ........... %ibits .. de               %i a                %i \n\n",bits,tipo_short_int,tipo_short_int_max);
  42. bits=0;
  43. while(tipo_unsigned_short_int>0){
  44. tipo_unsigned_short_int_max=tipo_unsigned_short_int+(tipo_unsigned_short_int-1);
  45. tipo_unsigned_short_int=tipo_unsigned_short_int*2;
  46. //printf("admite como maximo: %i \n\n",tipo_unsigned_short_int);
  47. bits++;
  48. }
  49. printf("unsigned short int .. %ibits .. de                    %i a                %i \n\n",bits,tipo_unsigned_short_int,tipo_unsigned_short_int_max);
  50. bits=1;
  51. while(tipo_int>0){
  52. tipo_int_max=tipo_int+(tipo_int-1);
  53. tipo_int=tipo_int*2;
  54. //printf("admite como maximo: %i \n\n",tipo_long_int);
  55. bits++;
  56. }
  57. printf("int ................. %ibits .. de          %i a           %i \n\n",bits,tipo_int,tipo_int_max);
  58. bits=1;
  59. while(tipo_long>0){
  60. tipo_long_max=tipo_long+(tipo_long-1);
  61. tipo_long=tipo_long*2;
  62. //printf("admite como maximo: %ld \n\n",tipo_long_int);
  63. bits++;
  64. }
  65. printf("long ................ %ibits .. de          %ld a           %ld \n\n",bits,tipo_long,tipo_long_max);
  66. bits=1;
  67. while(tipo_long_int>0){
  68. tipo_long_int_max=tipo_long_int+(tipo_long_int-1);
  69. tipo_long_int=tipo_long_int*2;
  70. //printf("admite como maximo: %i \n\n",tipo_long_int);
  71. bits++;
  72. }
  73. printf("long int ............ %ibits .. de          %i a           %i \n\n",bits,tipo_long_int,tipo_long_int_max);
  74. bits=0;
  75. while(tipo_unsigned_long_int>0){
  76. tipo_unsigned_long_int_max=tipo_unsigned_long_int+(tipo_unsigned_long_int-1);
  77. tipo_unsigned_long_int=tipo_unsigned_long_int*2;
  78. //printf("admite como maximo: %i \n\n",tipo_unsigned_long_int);
  79. bits++;
  80. }
  81. printf("unsigned long int ... %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_long_int,tipo_unsigned_long_int_max);
  82. bits=0;
  83. while(tipo_unsigned_int>0){
  84. tipo_unsigned_int_max=tipo_unsigned_int+(tipo_unsigned_int-1);
  85. tipo_unsigned_int=tipo_unsigned_int*2;
  86. //printf("admite como maximo: %i \n\n",tipo_unsigned_int);
  87. bits++;
  88. }
  89. printf("unsigned int ........ %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_int,tipo_unsigned_int_max);
  90. bits=0;
  91. while(tipo_unsigned_long>0){
  92. tipo_unsigned_long_max=tipo_unsigned_long+(tipo_unsigned_long-1);
  93. tipo_unsigned_long=tipo_unsigned_long*2;
  94. //printf("admite como maximo: %i \n\n",tipo_unsigned_long);
  95. bits++;
  96. }
  97. printf("unsigned long ....... %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_long,tipo_unsigned_long_max);
  98. bits=1;
  99. while(tipo_long_long>0){
  100. tipo_long_long_max=tipo_long_long+(tipo_long_long-1);
  101. tipo_long_long=tipo_long_long*2;
  102. //printf("admite como maximo: %ll \n",tipo_long_long);
  103. bits++;
  104. }
  105. printf("long long ........... %ibits .. de %lld a  %lld \n\n",bits,tipo_long_long,tipo_long_long_max);
  106. bits=0;
  107. while(tipo_unsigned_long_long>0){
  108. tipo_unsigned_long_long_max=tipo_unsigned_long_long+(tipo_unsigned_long_long-1);
  109. tipo_unsigned_long_long=tipo_unsigned_long_long*2;
  110. //printf("admite como maximo: %llu \n",tipo_unsigned_long_long);
  111. bits++;
  112. }
  113. printf("unsigned long long .. %ibits .. de                    %llu a %llu \n\n",bits,tipo_unsigned_long_long,tipo_unsigned_long_long_max);
  114.  
  115. system("pause");
  116.  
  117.  
  118. /*
  119. %d--> for int
  120.  
  121. %ld--> for long int
  122.  
  123. %lld--> for long long int
  124.  
  125. %llu--> for unsigned long long int
  126. */
  127. }
  128.  

Y el resultado con Notepad++ y MinGW es este:

Citar
char ................. 8bits de                    -128 a                  127

unsigned char ........ 8bits .. de                    0 a                  255

short int ........... 16bits .. de               -32768 a                32767

unsigned short int .. 16bits .. de                    0 a                65535

int ................. 32bits .. de          -2147483648 a           2147483647

long ................ 32bits .. de          -2147483648 a           2147483647

long int ............ 32bits .. de          -2147483648 a           2147483647

unsigned long int ... 32bits .. de                    0 a           4294967295

unsigned int ........ 32bits .. de                    0 a           4294967295

unsigned long ....... 32bits .. de                    0 a           4294967295

long long ........... 64bits .. de -9223372036854775808 a  9223372036854775807

unsigned long long .. 64bits .. de                    0 a 18446744073709551615
42  Programación / Programación C/C++ / Re: Laberinto C++ en: 26 Septiembre 2016, 18:08 pm
No entiendo lo que haces.

A mi compilando tu codigo me da esto:

Citar
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # .
. # # # . . . # # # # #

Cual es el resultado esperado? No veo ningun camino en el laberinto
43  Comunicaciones / Redes / Un equipo que no reconozco apareció en la vista de equipos en red en: 26 Septiembre 2016, 17:37 pm
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?
44  Programación / Programación C/C++ / Re: Consulta Archivos en C en: 21 Septiembre 2016, 13:57 pm
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.
45  Programación / Programación C/C++ / Re: Ayuda!! Problema de ejecución en un bucle en: 21 Septiembre 2016, 13:38 pm
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:
Citar
//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
  1. #include <iostream>
  2.  
  3. //PROGRAMA QUE DEVUELVE UN VALOR "PISO" SEGUN LA EDAD INGRESADA
  4.  
  5. using namespace std;
  6.  
  7. main()
  8. {
  9.        string name;
  10.        int edad;
  11.  
  12.        cout<<"Introduzca su nombre :";
  13. cin>>name;
  14.        cout<<"Digite su edad :";
  15. cin>>edad;
  16.  
  17.        cout<<"\n"<<name<<" VA AL ";
  18.  
  19. if(edad>=0 && edad<=9)cout<<"PISO 0";
  20. else if(edad>=10 && edad<=19)cout<<"PISO 1";
  21. else if(edad>=20 && edad<=29)cout<<"PISO 2";
  22. else if(edad>=30 && edad<=39)cout<<"PISO 3";
  23. else if(edad>=40 && edad<=49)cout<<"PISO 4";
  24. else if(edad>=50 && edad<=59)cout<<"PISO 5";
  25. else if(edad>=60 && edad<=69)cout<<"PISO 6";
  26. else if(edad>=70 && edad<=79)cout<<"PISO 7";
  27. else
  28. cout<<"\nERROR"<<endl;
  29.  
  30. cout<<endl;
  31. }

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.
46  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 5 Agosto 2016, 11:47 am
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?
47  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 3 Agosto 2016, 17:36 pm
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?
48  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 2 Agosto 2016, 19:11 pm
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.

49  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 2 Agosto 2016, 13:13 pm
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?
50  Programación / Programación C/C++ / Re: Poniendo a prueba los tipos de variables en c en: 2 Agosto 2016, 12:31 pm
Vale ya he visto que tengo mal el formato en los printf. Voy a revisarlo
Páginas: 1 2 3 4 [5] 6 7 8
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines