Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: Fluflu en 29 Agosto 2010, 17:45 pm


Título: Pido Corrección: Conversor Informática
Publicado por: Fluflu 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. }

Título: Re: Pido Corrección: Conversor Informática
Publicado por: pucheto 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).

Título: Re: Pido Corrección: Conversor Informática
Publicado por: clodan 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. }

Título: Re: Pido Corrección: Conversor Informática
Publicado por: Fluflu 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.

Título: Re: Pido Corrección: Conversor Informática
Publicado por: clodan en 31 Agosto 2010, 02:38 am
Cita de: Fluflu 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.

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...

Título: Re: Pido Corrección: Conversor Informática
Publicado por: carlitos_jajajajaja 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





Título: Re: Pido Corrección: Conversor Informática
Publicado por: clodan en 31 Agosto 2010, 05:53 am
Cita de: carlitos_jajajajaja 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



CLAAAA!!!! eso es lo que buscaba!!! jaajaja gracias!!!


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines