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

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Pido Corrección: Conversor Informática
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Pido Corrección: Conversor Informática  (Leído 2,980 veces)
Fluflu

Desconectado Desconectado

Mensajes: 137



Ver Perfil
Pido Corrección: Conversor Informática
« en: 29 Agosto 2010, 17:45 pm »

Hola, estoy intentando aprender a programar y para poner en práctica unas cuantas cosas que he estudiado he hecho este programa que convierte cantidades de bits, megabits, bytes, kilobytes, megabytes, gigabytes y terabytes. Se que seguramente habrá código inútil y lo debo de haber hecho demasiado largo para tan poca cosa. Viendo el nivel que tengo ¿Me podríais dar algunas críticas constructivas? Remarco lo  de mi nivel, cosas que pueda entender. Bueno, supongo que leyéndolo se verá que está desarrollado en entorno Linux. Gracias :)

Código
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. int main() {
  5.  
  6. char bit[] = "bits";
  7. char megabit[] = "Mb";
  8. char byte[] = "bytes";
  9. char kbyte[] = "KB";
  10. char megabyte[] = "MB";
  11. char gigabyte[] = "GB";
  12. char terabyte[] = "TB";
  13.  
  14. int opc1;
  15. int opc2;
  16.  
  17. /* Guarda la opción escogida por el usuario sobre el tipo de dato en las variables opc1 y opc2 */
  18. system("clear");
  19. printf("\n1.bit\n2.megabit\n3.byte\n4.kbyte\n5.megabyte\n6.gigabyte\n7.terabyte\n\nIntroduce el tipo de dato origen: ");
  20. scanf("%i", &opc1);
  21.  
  22. system("clear");
  23. printf("\n1.bit\n2.megabit\n3.byte\n4.kbyte\n5.megabyte\n6.gigabyte\n7.terabyte\n\nIntroduce el tipo de dato destino: ");
  24. scanf("%i", &opc2);
  25.  
  26. /* Variables para el número introducido por el usuario y el resultado del cálculo */
  27. float num;
  28. float result;
  29.  
  30. /* Variables para indicar el tipo de dato original y final. */
  31. char ori[6];
  32. char fin[6];
  33.  
  34. /* Cálculo del resultado */
  35. system("clear");
  36. printf("\nIntroduce la cifra: ");
  37. scanf("%f", &num);
  38.  
  39. switch(opc1)
  40. {
  41. case 1:
  42. strcpy(ori, bit);
  43. switch(opc2)
  44. {
  45. case 1:
  46. strcpy(fin, bit);
  47. result = num;
  48. break;
  49.  
  50. case 2:
  51. strcpy(fin, megabit);
  52. result = num / 1000000;
  53. break;
  54.  
  55. case 3:
  56. strcpy(fin, byte);
  57. result = num / 8;
  58. break;
  59.  
  60. case 4:
  61. strcpy(fin, kbyte);
  62. result = num / 1024;
  63. break;
  64.  
  65. case 5:
  66. strcpy(fin, megabyte);
  67. result = num / 1024 / 1024;
  68. break;
  69.  
  70. case 6:
  71. strcpy(fin, gigabyte);
  72. result = num / 1024 / 1024 / 1024;
  73. break;
  74.  
  75. case 7:
  76. strcpy(fin, terabyte);
  77. result = num / 1024 / 1024 / 1024 / 1024;
  78. break;
  79. }
  80. break;
  81.  
  82. case 2:
  83. strcpy(ori, megabit);
  84. switch(opc2)
  85. {
  86. case 1:
  87. strcpy(fin, bit);
  88. result = num * 1000000;
  89. break;
  90.  
  91. case 2:
  92. strcpy(fin, megabit);
  93. result = num;
  94. break;
  95.  
  96. case 3:
  97. strcpy(fin, byte);
  98. result = num * 1000000 / 8;
  99. break;
  100.  
  101. case 4:
  102. strcpy(fin, kbyte);
  103. result = num * 1000000 / 8 / 1024;
  104. break;
  105.  
  106. case 5:
  107. strcpy(fin, megabyte);
  108. result = num * 1000000 / 8 / 1024 / 1024;
  109. break;
  110.  
  111. case 6:
  112. strcpy(fin, gigabyte);
  113. result = num * 1000000 / 8 / 1024 / 1024 / 1024;
  114. break;
  115.  
  116. case 7:
  117. strcpy(fin, terabyte);
  118. result = num * 1000000 / 8 / 1024 / 1024 / 1024 / 1024;
  119. break;
  120. }
  121. break;
  122.  
  123. case 3:
  124. strcpy(ori, byte);
  125. switch(opc2)
  126. {
  127. case 1:
  128. strcpy(fin, bit);
  129. result = num * 8;
  130. break;
  131.  
  132. case 2:
  133. strcpy(fin, megabit);
  134. result = num * 8 / 1000000  ;
  135. break;
  136.  
  137. case 3:
  138. strcpy(fin, byte);
  139. result = num;
  140. break;
  141.  
  142. case 4:
  143. strcpy(fin, kbyte);
  144. result = num / 1024;
  145. break;
  146.  
  147. case 5:
  148. strcpy(fin, megabyte);
  149. result = num / 1024 / 1024;
  150. break;
  151.  
  152. case 6:
  153. strcpy(fin, gigabyte);
  154. result = num / 1024 / 1024 / 1024;
  155. break;
  156.  
  157. case 7:
  158. strcpy(fin, terabyte);
  159. result = num / 1024 / 1024 / 1024 / 1024;
  160. break;
  161. }
  162. break;
  163.  
  164.    case 4:
  165. strcpy(ori, kbyte);
  166. switch(opc2)
  167. {
  168. case 1:
  169. strcpy(fin, bit);
  170. result = num * 1024 * 8;
  171. break;
  172.  
  173. case 2:
  174. strcpy(fin, megabit);
  175. result = num * 1024 * 8 / 1000000  ;
  176. break;
  177.  
  178. case 3:
  179. strcpy(fin, byte);
  180. result = num *1024;
  181. break;
  182.  
  183. case 4:
  184. strcpy(fin, kbyte);
  185. result = num;
  186. break;
  187.  
  188. case 5:
  189. strcpy(fin, megabyte);
  190. result = num / 1024;
  191. break;
  192.  
  193. case 6:
  194. strcpy(fin, gigabyte);
  195. result = num / 1024 / 1024;
  196. break;
  197.  
  198. case 7:
  199. strcpy(fin, terabyte);
  200. result = num / 1024 / 1024 / 1024;
  201. break;
  202. }
  203. break;
  204.  
  205. case 5:
  206. strcpy(ori, megabyte);
  207. switch(opc2)
  208. {
  209. case 1:
  210. strcpy(fin, bit);
  211. result = num * 1024 * 1024 * 8;
  212. break;
  213.  
  214. case 2:
  215. strcpy(fin, megabit);
  216. result = num * 1024 * 1024 * 8 / 1000000  ;
  217. break;
  218.  
  219. case 3:
  220. strcpy(fin, byte);
  221. result = num * 1024 * 1024;
  222. break;
  223.  
  224. case 4:
  225. strcpy(fin, kbyte);
  226. result = num * 1024;
  227. break;
  228.  
  229. case 5:
  230. strcpy(fin, megabyte);
  231. result = num;
  232. break;
  233.  
  234. case 6:
  235. strcpy(fin, gigabyte);
  236. result = num / 1024 / 1024;
  237. break;
  238.  
  239. case 7:
  240. strcpy(fin, terabyte);
  241. result = num / 1024 / 1024 / 1024;
  242. break;
  243. }
  244. break;
  245.  
  246. case 6:
  247. strcpy(ori, gigabyte);
  248. switch(opc2)
  249. {
  250. case 1:
  251. strcpy(fin, bit);
  252. result = num * 1024 * 1024 * 1024 * 8;
  253. break;
  254.  
  255. case 2:
  256. strcpy(fin, megabit);
  257. result = num * 1024 * 1024 * 1024 * 8 / 1000000  ;
  258. break;
  259.  
  260. case 3:
  261. strcpy(fin, byte);
  262. result = num * 1024 * 1024 * 1024;
  263. break;
  264.  
  265. case 4:
  266. strcpy(fin, kbyte);
  267. result = num * 1024 * 1024;
  268. break;
  269.  
  270. case 5:
  271. strcpy(fin, megabyte);
  272. result = num * 1024;
  273. break;
  274.  
  275. case 6:
  276. strcpy(fin, gigabyte);
  277. result = num;
  278. break;
  279.  
  280. case 7:
  281. strcpy(fin, terabyte);
  282. result = num / 1024;
  283. break;
  284. }
  285. break;
  286.  
  287. case 7:
  288. strcpy(ori, terabyte);
  289. switch(opc2)
  290. {
  291. case 1:
  292. strcpy(fin, bit);
  293. result = num * 1024 * 1024 * 1024 * 1024 * 8;
  294. break;
  295.  
  296. case 2:
  297. strcpy(fin, megabit);
  298. result = num * 1024 * 1024 * 1024 * 1024 * 8 / 1000000  ;
  299. break;
  300.  
  301. case 3:
  302. strcpy(fin, byte);
  303. result = num * 1024 * 1024 * 1024 * 1024;
  304. break;
  305.  
  306. case 4:
  307. strcpy(fin, kbyte);
  308. result = num * 1024 * 1024 * 1024;
  309. break;
  310.  
  311. case 5:
  312. strcpy(fin, megabyte);
  313. result = num * 1024 * 1024;
  314. break;
  315.  
  316. case 6:
  317. strcpy(fin, gigabyte);
  318. result = num * 1024;
  319. break;
  320.  
  321. case 7:
  322. strcpy(fin, terabyte);
  323. result = num;
  324. break;
  325. }
  326. break;
  327. }
  328.  
  329. /* Impresión en pantalla del resultado. */
  330. system("clear");
  331. printf("\n");
  332. printf("\n%f %s es igual a: %f %s\n", num, ori, result, fin);
  333. printf("\n");
  334.  
  335. return 0;
  336.  
  337. }


« Última modificación: 30 Agosto 2010, 00:45 am por Fluflu » En línea

La puerta más segura es la que no necesita ser cerrada...
pucheto

Desconectado Desconectado

Mensajes: 215


Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #1 en: 30 Agosto 2010, 03:50 am »

Te tiro una pista para q quede mas lindo, podes hacerlo como ejercicio.

   char bit[] = "bits";
   char megabit[] = "Mb";
   char byte[] = "bytes";
   char kbyte[] = "KB";
   char megabyte[] = "MB";
   char gigabyte[] = "GB";
   char terabyte[] = "TB";

Todas esas variables que declaraste, comparten tipo, y ademas podemos decir q comparten "función u objetivo" (no se me ocurre una manera prolija de decirlo).
Proba metiendolas en un array, de manera q la opcion "i" te manda a la unidad en la i-esima posicion. Eso simplificaría el switch, (algo similar también para la conversión).


En línea

clodan

Desconectado Desconectado

Mensajes: 277



Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #2 en: 30 Agosto 2010, 17:23 pm »

mmm yo no le veo nada mal, eso si, tal como dijo nuestro compañero, las variables que tengan igual tipo es mejor agruparlas en 1 sola linea, pero eso depende de tus gustos...

mmm despues... ahh... dejo aca para que los que tengan windows puedan tambien ver los problemas sin inconvenientes...

mmm no se en linux, pero al final tenes qe poner un system pause, o getchar () para que muestre el resultado, sino el programa se cierra y por la velocidad a la que pasa todo es imposible ver el resultado, pero el programa funciona barbaro...

si queres hacer para ambas versiones, windows y linux, lo que podes hacer es una funcion que diga

if system("cls")=error
system("clear")
else
system("cls")

el problema es que justo ahora no me acuerdo como era para escribir error de comando...

para windows:
Código
  1. #include <stdio.h>
  2. #include <string.h>
  3. int main() {
  4.      char bit[] = "bits";
  5.      char megabit[] = "Mb";
  6.      char byte[] = "bytes";
  7.      char kbyte[] = "KB";
  8.      char megabyte[] = "MB";
  9.      char gigabyte[] = "GB";
  10.      char terabyte[] = "TB";
  11.      int opc1;
  12.      int opc2;
  13. /* Guarda la opción escogida por el usuario sobre el tipo de dato en las variables opc1 y opc2 */
  14.  
  15. system("cls");
  16. printf("\n1.bit\n2.megabit\n3.byte\n4.kbyte\n5.megabyte\n6.gigabyte\n7.terabyte\n\nIntroduce el tipo de dato origen: ");
  17. scanf("%i", &opc1);
  18. system("cls");
  19. printf("\n1.bit\n2.megabit\n3.byte\n4.kbyte\n5.megabyte\n6.gigabyte\n7.terabyte\n\nIntroduce el tipo de dato destino: ");
  20. scanf("%i", &opc2);
  21.  
  22. /* Variables para el número introducido por el usuario y el resultado del cálculo */
  23.  
  24. float num;
  25. float result;
  26.  
  27. /* Variables para indicar el tipo de dato original y final. */
  28.  
  29. char ori[6];
  30. char fin[6];
  31.  
  32. /* Cálculo del resultado */
  33.  
  34. system("cls");
  35. printf("\nIntroduce la cifra: ");
  36. scanf("%f", &num);
  37.  
  38. switch(opc1) {
  39.              case 1:
  40.                   strcpy(ori, bit);
  41.                   switch(opc2) {
  42.                                 case 1:
  43.                                      strcpy(fin, bit);
  44.                                      result = num;
  45.                                      break;
  46.                                 case 2:
  47.                                      strcpy(fin, megabit);
  48.                                      result = num / 1000000;
  49.                                      break;
  50.                                 case 3:
  51.                                      strcpy(fin, byte);
  52.                                      result = num / 8;
  53.                                      break;
  54.                                 case 4:
  55.                                      strcpy(fin, kbyte);
  56.                                      result = num / 1024;
  57.                                      break;
  58.                                 case 5:
  59.                                      strcpy(fin, megabyte);
  60.                                      result = num / 1024 / 1024;
  61.                                      break;
  62.                                 case 6:
  63.                                      strcpy(fin, gigabyte);
  64.                                      result = num / 1024 / 1024 / 1024;
  65.                                      break;
  66.                                 case 7:
  67.                                      strcpy(fin, terabyte);
  68.                                      result = num / 1024 / 1024 / 1024 / 1024;
  69.                                      break;
  70.                                      }
  71.                   break;
  72.              case 2:
  73.                   strcpy(ori, megabit);
  74.                   switch(opc2) {
  75.                                 case 1:
  76.                                      strcpy(fin, bit);
  77.                                      result = num * 1000000;
  78.                                      break;
  79.                                 case 2:
  80.                                      strcpy(fin, megabit);
  81.                                      result = num;
  82.                                      break;
  83.                                 case 3:
  84.                                      strcpy(fin, byte);
  85.                                      result = num * 1000000 / 8;
  86.                                      break;
  87.                                 case 4:
  88.                                      strcpy(fin, kbyte);
  89.                                      result = num * 1000000 / 8 / 1024;
  90.                                      break;
  91.                                 case 5:
  92.                                      strcpy(fin, megabyte);
  93.                                      result = num * 1000000 / 8 / 1024 / 1024;
  94.                                      break;
  95.                                 case 6:
  96.                                      strcpy(fin, gigabyte);
  97.                                      result = num * 1000000 / 8 / 1024 / 1024 / 1024;
  98.                                      break;
  99.                                 case 7:
  100.                                      strcpy(fin, terabyte);
  101.                                      result = num * 1000000 / 8 / 1024 / 1024 / 1024 / 1024;
  102.                                 break;
  103.                                 }
  104.                   break;
  105.              case 3:
  106.                   strcpy(ori, byte);
  107.                   switch(opc2) {
  108.                                 case 1:
  109.                                      strcpy(fin, bit);
  110.                                      result = num * 8;
  111.                                      break;
  112.                                 case 2:
  113.                                      strcpy(fin, megabit);
  114.                                      result = num * 8 / 1000000  ;
  115.                                      break;
  116.                                 case 3:
  117.                                      strcpy(fin, byte);
  118.                                      result = num;
  119.                                      break;
  120.                                 case 4:
  121.                                      strcpy(fin, kbyte);
  122.                                      result = num / 1024;
  123.                                      break;
  124.                                 case 5:
  125.                                      strcpy(fin, megabyte);
  126.                                      result = num / 1024 / 1024;
  127.                                      break;
  128.                                 case 6:
  129.                                      strcpy(fin, gigabyte);
  130.                                      result = num / 1024 / 1024 / 1024;
  131.                                      break;
  132.                                 case 7:
  133.                                      strcpy(fin, terabyte);
  134.                                      result = num / 1024 / 1024 / 1024 / 1024;
  135.                                      break;
  136.                                      }
  137.                   break;    
  138.              case 4:
  139.                   strcpy(ori, kbyte);
  140.                   switch(opc2) {
  141.                                 case 1:
  142.                                      strcpy(fin, bit);
  143.                                      result = num * 1024 * 8;
  144.                                      break;
  145.                                 case 2:
  146.                                      strcpy(fin, megabit);
  147.                                      result = num * 1024 * 8 / 1000000  ;
  148.                                      break;
  149.                                 case 3:
  150.                                      strcpy(fin, byte);
  151.                                      result = num *1024;
  152.                                      break;
  153.                                 case 4:
  154.                                      strcpy(fin, kbyte);
  155.                                      result = num;
  156.                                      break;
  157.                                 case 5:
  158.                                      strcpy(fin, megabyte);
  159.                                      result = num / 1024;
  160.                                      break;
  161.                                 case 6:
  162.                                      strcpy(fin, gigabyte);
  163.                                      result = num / 1024 / 1024;
  164.                                      break;
  165.                                 case 7:
  166.                                      strcpy(fin, terabyte);
  167.                                      result = num / 1024 / 1024 / 1024;
  168.                                      break;
  169.                                      }
  170.                   break;
  171.              case 5:
  172.                   strcpy(ori, megabyte);
  173.                   switch(opc2) {
  174.                                 case 1:
  175.                                      strcpy(fin, bit);
  176.                                      result = num * 1024 * 1024 * 8;
  177.                                      break;
  178.                                 case 2:
  179.                                      strcpy(fin, megabit);
  180.                                      result = num * 1024 * 1024 * 8 / 1000000  ;
  181.                                      break;
  182.                                 case 3:
  183.                                      strcpy(fin, byte);
  184.                                      result = num * 1024 * 1024;
  185.                                      break;
  186.                                 case 4:
  187.                                      strcpy(fin, kbyte);
  188.                                      result = num * 1024;
  189.                                      break;
  190.                                 case 5:
  191.                                      strcpy(fin, megabyte);
  192.                                      result = num;
  193.                                      break;
  194.                                 case 6:
  195.                                      strcpy(fin, gigabyte);
  196.                                      result = num / 1024 / 1024;
  197.                                      break;
  198.                                 case 7:
  199.                                      strcpy(fin, terabyte);
  200.                                      result = num / 1024 / 1024 / 1024;
  201.                                      break;
  202.                                      }
  203.                   break;
  204.              case 6:
  205.                   strcpy(ori, gigabyte);
  206.                   switch(opc2) {
  207.                                 case 1:
  208.                                      strcpy(fin, bit);
  209.                                      result = num * 1024 * 1024 * 1024 * 8;
  210.                                      break;
  211.                                 case 2:
  212.                                      strcpy(fin, megabit);
  213.                                      result = num * 1024 * 1024 * 1024 * 8 / 1000000  ;
  214.                                      break;
  215.                                 case 3:
  216.                                      strcpy(fin, byte);
  217.                                      result = num * 1024 * 1024 * 1024;
  218.                                      break;
  219.                                 case 4:
  220.                                      strcpy(fin, kbyte);
  221.                                      result = num * 1024 * 1024;
  222.                                      break;
  223.                                 case 5:
  224.                                      strcpy(fin, megabyte);
  225.                                      result = num * 1024;
  226.                                      break;
  227.                                 case 6:
  228.                                      strcpy(fin, gigabyte);
  229.                                      result = num;
  230.                                      break;
  231.                                 case 7:
  232.                                      strcpy(fin, terabyte);
  233.                                      result = num / 1024;
  234.                                      break;
  235.                                      }
  236.                   break;
  237.              case 7:
  238.                   strcpy(ori, terabyte);
  239.                   switch(opc2) {                  
  240.                                 case 1:
  241.                                      strcpy(fin, bit);
  242.                                      result = num * 1024 * 1024 * 1024 * 1024 * 8;
  243.                                      break;
  244.                                 case 2:
  245.                                      strcpy(fin, megabit);
  246.                                      result = num * 1024 * 1024 * 1024 * 1024 * 8 / 1000000  ;
  247.                                      break;
  248.                                 case 3:
  249.                                      strcpy(fin, byte);
  250.                                      result = num * 1024 * 1024 * 1024 * 1024;
  251.                                      break;
  252.                                 case 4:
  253.                                      strcpy(fin, kbyte);
  254.                                      result = num * 1024 * 1024 * 1024;
  255.                                      break;
  256.                                 case 5:
  257.                                      strcpy(fin, megabyte);
  258.                                      result = num * 1024 * 1024;
  259.                                      break;
  260.                                 case 6:
  261.                                      strcpy(fin, gigabyte);
  262.                                      result = num * 1024;
  263.                                      break;
  264.                                 case 7:
  265.                                      strcpy(fin, terabyte);
  266.                                      result = num;
  267.                                      break;
  268.                                      }
  269.                   break;
  270.              }
  271. /* Impresión en pantalla del resultado. */
  272. system("cls");
  273. printf("\n");
  274. printf("\n%f %s es igual a: %f %s\n", num, ori, result, fin);
  275. printf("\n");
  276. system("PAUSE");
  277. return 0;
  278.  
  279. }
En línea

Fluflu

Desconectado Desconectado

Mensajes: 137



Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #3 en: 31 Agosto 2010, 01:45 am »

Gracias por responder, os haré caso con lo del array, respecto a lo de system("pause"); al hacerlo en linux no lo necesito (al menos de momento) porque ejecuto los programas desde la terminal, de forma que el resultado queda visible, pero lo tendré en cuenta si programo en windows y no me interesa abrirlo desde la consola.

Y gracias también por esto:

Citar
if system("cls")=error
system("clear")
else
system("cls")

no se me había ocurrido. ;-)

Si alguien quiere seguir añadiendo cosas lo agradeceré también.
En línea

La puerta más segura es la que no necesita ser cerrada...
clodan

Desconectado Desconectado

Mensajes: 277



Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #4 en: 31 Agosto 2010, 02:38 am »

Gracias por responder, os haré caso con lo del array, respecto a lo de system("pause"); al hacerlo en linux no lo necesito (al menos de momento) porque ejecuto los programas desde la terminal, de forma que el resultado queda visible, pero lo tendré en cuenta si programo en windows y no me interesa abrirlo desde la consola.

Y gracias también por esto:

Citar
if system("cls")=error
system("clear")
else
system("cls")

no se me había ocurrido. ;-)

Si alguien quiere seguir añadiendo cosas lo agradeceré también.

igual mira qe ese codigo no existe ehh!! lo vi aca una vez pero no me acuerdo como se ponia cuando un comando da error... por eso...
En línea

carlitos_jajajajaja

Desconectado Desconectado

Mensajes: 30


Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #5 en: 31 Agosto 2010, 05:07 am »

Una forma mas sencilla de hacerlo es  usando macros...


Despues de los includes, colocas esto
Código
  1. #ifdef WINDOWS
  2.     #define CLEAR_COMMAND "cls"
  3. #elif defined(UNIX)
  4.     #define CLEAR_COMMAND "clear"
  5. #else
  6.     #error "No programas ni en Windows ni en Linux?? Eres raro!!!"
  7. #endif
  8.  

Las macros WINDOWS y UNIX las define normalmente tu compilador de preferencia, no necesariamente con esos nombres, pero averigua q nombres usa

Luego, a la hora de hacer la llamada al sistema para limpiar pantalla:
Código
  1. system(CLEAR_COMMAND);
  2.  

Y tienes codigo limpio portable y elegante :D




En línea

Merodeo los foros, esperando el momento de decir algo inteligente...

Se necesita paciencia
clodan

Desconectado Desconectado

Mensajes: 277



Ver Perfil
Re: Pido Corrección: Conversor Informática
« Respuesta #6 en: 31 Agosto 2010, 05:53 am »

Una forma mas sencilla de hacerlo es  usando macros...


Despues de los includes, colocas esto
Código
  1. #ifdef WINDOWS
  2.     #define CLEAR_COMMAND "cls"
  3. #elif defined(UNIX)
  4.     #define CLEAR_COMMAND "clear"
  5. #else
  6.     #error "No programas ni en Windows ni en Linux?? Eres raro!!!"
  7. #endif
  8.  

Las macros WINDOWS y UNIX las define normalmente tu compilador de preferencia, no necesariamente con esos nombres, pero averigua q nombres usa

Luego, a la hora de hacer la llamada al sistema para limpiar pantalla:
Código
  1. system(CLEAR_COMMAND);
  2.  

Y tienes codigo limpio portable y elegante :D



CLAAAA!!!! eso es lo que buscaba!!! jaajaja gracias!!!
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
¿Que esta mal? [Correccion de codigo]
PHP
2Fac3R 8 3,075 Último mensaje 4 Noviembre 2011, 18:18 pm
por 2Fac3R
Corrección de apuntes sobre Java
Java
Dster 1 1,809 Último mensaje 20 Octubre 2012, 00:14 am
por sapito169
Corrección de programa en C
Programación C/C++
Xgirl12 5 2,461 Último mensaje 7 Noviembre 2012, 22:52 pm
por Xgirl12
Corrección de ejercicio
Programación C/C++
Soulklax 9 4,096 Último mensaje 7 Noviembre 2016, 18:14 pm
por Soulklax
Corrección ejercicio en C de un bingo
Programación C/C++
vaillo33 6 3,155 Último mensaje 11 Enero 2019, 21:57 pm
por vaillo33
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines