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

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / [C/C++] Conversor Julios <-> Electrón-Voltios en: 5 Octubre 2013, 20:34 pm
Este es un pequeño proyecto de media hora.

El programa realiza conversiones entre Julios y Electrón-Voltios en los dos sentidos posibles según indique el usuario, pretende ser una ayuda para no tener que insertar números largos en la calculadora para resolver problemas problemas de
Química de 2º de Bachillerato. Pero es más bien un pequeño reto de programación para principiantes (como yo).

Compilado con MinGW.

Funciona perfectamente bajo Windows, funciona parcialmente bajo GNU/Linux por la códificación de la funcion LimpiarPantalla(); pero no es nada grave. El código está escrito en C usando sólo las cabeceras estándar y está comentado completamente en español.

El programa es software libre y contiene copyleft, lo cual quiere decir que puesdes redistribuir, modificar el código y demás sólamente bajo los términos de la Licencia General Pública de GNU (GPL).

Versión 0.0.1 (No creo que haga falta ninguna otra versión a no ser que
aprenda a hacer GUIs y lo actualice, pero la simplicidad es buena para aprender).

Aquí el código:

Código
  1. /*Cabeceras incluidas*/
  2. #include <stdio.h>  /*Cabecera estándar*/
  3. #include <stdlib.h> /*Cabecera estándar*/
  4.  
  5. /*Funciones declaradas (prototipos)*/
  6. void limpiarBuffer (void);     /*Limpia el buffer de entrada*/
  7. void limpiarPantalla (void);   /*Limpia la pantalla de la consola del sistema*/
  8. void menu (void);              /*Imprime un pequeño menú de bienvenida*/
  9. void sentidoConversion (void); /*Indica el sentido en el que se realizará la conversión*/
  10. void J_Ev (void);              /*Realiza la conversion de Julios a Electron-Voltios*/
  11. void Ev_J (void);              /*Realiza la conversion de Electron-Voltios a Julios*/
  12. void reinicio (void);          /*Reinicia o finaliza el programa*/
  13.  
  14. /*Funcion main*/
  15. int main (void)
  16. {
  17.     menu();
  18.     sentidoConversion();
  19.     reinicio();
  20.  
  21.     return 0;
  22. }
  23.  
  24. /*Funciones definidas (cuerpos de las funciones)*/
  25.  
  26. void limpiarBuffer (void) /*Limpia el buffer de entrada*/
  27. {
  28.     while (getchar() != '\n');
  29. }
  30.  
  31. void menu (void) /*Imprime un pequeño menú de bienvenida*/
  32. {
  33.     printf("--->Conversor Julios <-> Electron-Voltios\n");
  34. }
  35.  
  36. void limpiarPantalla (void) /*Limpia la pantalla de la consola del sistema*/
  37. {
  38.     system("cls");
  39. }
  40.  
  41. void sentidoConversion (void) /*Indica el sentido en el que se realizará la conversión*/
  42. {
  43.     /*Declaración de variables*/
  44.     unsigned char eleccion = 0; /*Valor por defecto en 0*/
  45.  
  46.     /*Trámites con el usuario*/
  47.     printf("Como desea realizar la conversion?:\n");
  48.     printf("[1] -> Julios -> Electron-Voltios\n");
  49.     printf("[2] -> Electron-Voltios -> Julios\n");
  50.     printf("Su eleccion: ");
  51.     scanf("%hhu", &eleccion);
  52.     limpiarBuffer();
  53.  
  54.     /*Derivar a una u otra funcion según la decisión del usuario*/
  55.     switch (eleccion)
  56.     {
  57.         case 1:
  58.             limpiarPantalla();
  59.             J_Ev();
  60.             break;
  61.         case 2:
  62.             limpiarPantalla();
  63.             Ev_J();
  64.             break;
  65.         default:
  66.             printf("ERROR: Inserte 1 o 2 segun el sentido de la conversion que desee.\n");
  67.             printf("Pulse [ENTER] para continuar...");
  68.             getchar();
  69.             limpiarPantalla();
  70.             sentidoConversion();
  71.             break;
  72.     }
  73. }
  74.  
  75. void J_Ev (void) /*Realiza la conversion de Julios a Electron-Voltios*/
  76. {
  77.     /*Declaración de variables*/
  78.     double J;
  79.     double Ev;
  80.     const double cargaElectron = 1.6e-19;
  81.  
  82.     /*Trámites con el usuario*/
  83.     printf("Julios a convertir: ");
  84.     scanf("%lf", &J);
  85.     limpiarBuffer();
  86.     printf("Convirtiendo...\n");
  87.  
  88.     /*Conversion*/
  89.     Ev = J/cargaElectron;
  90.     printf("%lg J = %lg Ev\n", J, Ev);
  91. }
  92.  
  93. void Ev_J (void) /*Realiza la conversion de Electron-Voltios a Julios*/
  94. {
  95.     /*Declaración de variables*/
  96.     double J;
  97.     double Ev;
  98.     const double cargaElectron = 1.6e-19;
  99.  
  100.     /*Trámites con el usuario*/
  101.     printf("Electron-Voltios a convertir: ");
  102.     scanf("%lf", &Ev);
  103.     limpiarBuffer();
  104.     printf("Convirtiendo...\n");
  105.  
  106.     /*Conversion*/
  107.     J = Ev*cargaElectron;
  108.     printf("%lg Ev = %lg J\n", J, Ev);
  109. }
  110.  
  111. void reinicio (void) /*Reinicia o finaliza el programa*/
  112. {
  113.     /*Declaración de variables*/
  114.     unsigned char eleccion = 0; /*Valor por defecto en 0*/
  115.  
  116.     /*Trámites con el usuario*/
  117.     printf("Desea realizar otra conversion?\n");
  118.     printf("[1] -> Si\n");
  119.     printf("[2] -> No\n");
  120.     printf("Su eleccion: ");
  121.     scanf("%hhu", &eleccion);
  122.     limpiarBuffer();
  123.  
  124.     /*Derivar a una u otra funcion según la decisión del usuario*/
  125.     switch (eleccion)
  126.     {
  127.         case 1:
  128.             limpiarPantalla();
  129.             main();
  130.             break;
  131.         case 2:
  132.             break;
  133.         default:
  134.             printf("ERROR: Inserte 1 o 2 la opcion que desee.\n");
  135.             printf("Pulse [ENTER] para continuar...");
  136.             getchar();
  137.             limpiarPantalla();
  138.             break;
  139.     }
  140. }
  141.  

Probablemente la química no sea de vuestra competencia, pero la informática sí, agradecería opiniones sobre el código, estoy abierto a críticas para mejorar.
2  Programación / Programación C/C++ / Funciones PROPIAS para manejo de strings en C/C++ en: 2 Septiembre 2013, 17:34 pm
He estado investigando últimamente sobre este tema del manejo de cadenas de caracteres en C y C++ y os traigo un código con 3 funciones que pueden resultar interesantes para este tema.

La primera función es un sustituto de strlen();

La segunda es un sucedáneo de toupper(); pero que cambia todo el texto de minúsculas a mayúsculas y no solo un caracter concreto.

La última es lo mismo que la anterior peor con tolower();

Código
  1. /*#include <stdio.h> en C*/
  2. #include <cstdio>
  3.  
  4. /*Prototipos de funciones utiles para el manejo de cadenas de caracteres*/
  5. inline size_t magnitudTexto (char texto []);
  6. inline void textoMayusculas (char texto [], size_t numeroCaracteres);
  7. inline void textoMinusculas (char texto [], size_t numeroCaracteres);
  8.  
  9. /*Funcion main*/
  10. int main (void)
  11. {
  12.     /*Declaracion de variables*/
  13.     const unsigned char CARACTERES_MAXIMOS = 140; /*Constante para no usar numeros magicos*/
  14.     char texto [CARACTERES_MAXIMOS]; /*Array de caracteres de 140 espacios*/
  15.     unsigned char caracteresTexto = 0;
  16.  
  17.     /*Tramites con el usuario*/
  18.     printf("Introduzca un texto: \n");
  19.     fgets(texto, CARACTERES_MAXIMOS, stdin); /*Uso de fgets(); para evitar desbordamientos de buffer*/
  20.  
  21.     /*Comprobaciones del funcionamiento de las funciones*/
  22.     caracteresTexto = magnitudTexto(texto);
  23.     printf("El texto tiene %hhu caracteres.\n", caracteresTexto); /*%hhu para variables unsigned char, de 0 a 255*/
  24.  
  25.     textoMayusculas(texto, caracteresTexto);
  26.     printf("El texto pasado a mayusculas:\n%s", texto);
  27.  
  28.     textoMinusculas(texto, caracteresTexto);
  29.     printf("El texto pasado a minusculas:\n%s", texto);
  30.  
  31.     return 0;
  32. }
  33.  
  34. inline size_t magnitudTexto (char texto [])
  35. {
  36.     size_t magnitud = 0;
  37.  
  38.     while (texto [magnitud] != '\0') /*Los arrays de caracteres finalizan con un \0*/
  39.     {
  40.         magnitud++;
  41.     }
  42.  
  43.     return magnitud;
  44. }
  45.  
  46. inline void textoMayusculas (char texto [], size_t numeroCaracteres)
  47. {
  48.     size_t contador = 0;
  49.  
  50.     while (contador <= numeroCaracteres)
  51.     {
  52.         if ((texto [contador] >= 'a') && (texto [contador] <= 'z'))
  53.         {
  54.             texto [contador] -= 'a' - 'A'; /*Consultar la tabla ASCII*/
  55.             contador++;
  56.         }
  57.         else
  58.         {
  59.             contador++;
  60.         }
  61.     }
  62. }
  63.  
  64. inline void textoMinusculas (char texto [], size_t numeroCaracteres)
  65. {
  66.     size_t contador = 0;
  67.  
  68.     while (contador <= numeroCaracteres)
  69.     {
  70.         if ((texto [contador] >= 'A') && (texto [contador <= 'Z']))
  71.         {
  72.             texto [contador] += 'a' - 'A';
  73.             contador++;
  74.         }
  75.         else
  76.         {
  77.             contador++;
  78.         }
  79.     }
  80. }
  81.  

Decidme qué os parece, si funciona correctamente y demás, yo lo he probado compilandolo en Code::Blocks en C++ bajo el compilador g++ en Ubuntu 13.04, debería funcionar en Windows también.

Corregido el error del static.
Corregido el error de tipos demasiado cortos (unsigned char).
Corregido el error de "+- 32".
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines