[C/C++] Conversor Julios <-> Electrón-Voltios

[Álvaro G. Tenorio]

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 (cpp) [Seleccionar] Expandir


/*Cabeceras incluidas*/
#include <stdio.h>  /*Cabecera estándar*/
#include <stdlib.h> /*Cabecera estándar*/

/*Funciones declaradas (prototipos)*/
void limpiarBuffer (void);     /*Limpia el buffer de entrada*/
void limpiarPantalla (void);   /*Limpia la pantalla de la consola del sistema*/
void menu (void);              /*Imprime un pequeño menú de bienvenida*/
void sentidoConversion (void); /*Indica el sentido en el que se realizará la conversión*/
void J_Ev (void);              /*Realiza la conversion de Julios a Electron-Voltios*/
void Ev_J (void);              /*Realiza la conversion de Electron-Voltios a Julios*/
void reinicio (void);          /*Reinicia o finaliza el programa*/

/*Funcion main*/
int main (void)
{
    menu();
    sentidoConversion();
    reinicio();

    return 0;
}

/*Funciones definidas (cuerpos de las funciones)*/

void limpiarBuffer (void) /*Limpia el buffer de entrada*/
{
    while (getchar() != '\n');
}

void menu (void) /*Imprime un pequeño menú de bienvenida*/
{
    printf("--->Conversor Julios <-> Electron-Voltios\n");
}

void limpiarPantalla (void) /*Limpia la pantalla de la consola del sistema*/
{
    system("cls");
}

void sentidoConversion (void) /*Indica el sentido en el que se realizará la conversión*/
{
    /*Declaración de variables*/
    unsigned char eleccion = 0; /*Valor por defecto en 0*/

    /*Trámites con el usuario*/
    printf("Como desea realizar la conversion?:\n");
    printf("[1] -> Julios -> Electron-Voltios\n");
    printf("[2] -> Electron-Voltios -> Julios\n");
    printf("Su eleccion: ");
    scanf("%hhu", &eleccion);
    limpiarBuffer();

    /*Derivar a una u otra funcion según la decisión del usuario*/
    switch (eleccion)
    {
        case 1:
            limpiarPantalla();
            J_Ev();
            break;
        case 2:
            limpiarPantalla();
            Ev_J();
            break;
        default:
            printf("ERROR: Inserte 1 o 2 segun el sentido de la conversion que desee.\n");
            printf("Pulse [ENTER] para continuar...");
            getchar();
            limpiarPantalla();
            sentidoConversion();
            break;
    }
}

void J_Ev (void) /*Realiza la conversion de Julios a Electron-Voltios*/
{
    /*Declaración de variables*/
    double J;
    double Ev;
    const double cargaElectron = 1.6e-19;

    /*Trámites con el usuario*/
    printf("Julios a convertir: ");
    scanf("%lf", &J);
    limpiarBuffer();
    printf("Convirtiendo...\n");

    /*Conversion*/
    Ev = J/cargaElectron;
    printf("%lg J = %lg Ev\n", J, Ev);
}

void Ev_J (void) /*Realiza la conversion de Electron-Voltios a Julios*/
{
    /*Declaración de variables*/
    double J;
    double Ev;
    const double cargaElectron = 1.6e-19;

    /*Trámites con el usuario*/
    printf("Electron-Voltios a convertir: ");
    scanf("%lf", &Ev);
    limpiarBuffer();
    printf("Convirtiendo...\n");

    /*Conversion*/
    J = Ev*cargaElectron;
    printf("%lg Ev = %lg J\n", J, Ev);
}

void reinicio (void) /*Reinicia o finaliza el programa*/
{
    /*Declaración de variables*/
    unsigned char eleccion = 0; /*Valor por defecto en 0*/

    /*Trámites con el usuario*/
    printf("Desea realizar otra conversion?\n");
    printf("[1] -> Si\n");
    printf("[2] -> No\n");
    printf("Su eleccion: ");
    scanf("%hhu", &eleccion);
    limpiarBuffer();

    /*Derivar a una u otra funcion según la decisión del usuario*/
    switch (eleccion)
    {
        case 1:
            limpiarPantalla();
            main();
            break;
        case 2:
            break;
        default:
            printf("ERROR: Inserte 1 o 2 la opcion que desee.\n");
            printf("Pulse [ENTER] para continuar...");
            getchar();
            limpiarPantalla();
            break;
    }
}


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.

[ivancea96]

Ahí veo que sobran muchas cosas.

void limpiarpantalla() sobra. pones el system("cls");, y es más legible, a mi parecer.

Tienes por separado "menu" y "sentidoconversion". Un menu es donde eliges las opciones, por tanto, el menu es esas 2 funciones unidas.

[MeCraniDOS]

En el main se pone el esqueleto del programa

Código (cpp) [Seleccionar] Expandir


int main (void)
{
   menu();
   sentidoConversion();
   reinicio();

   return 0;
}



1. Hay muchas cosas que sobran
2. Llamas a una función dentro de otra, si quieres reutilizar algo te dará problemas

Estas 3 funciones sobran

Código (cpp) [Seleccionar] Expandir

void limpiarBuffer (void) /*Limpia el buffer de entrada*/
{
   while (getchar() != '\n');
}

void menu (void) /*Imprime un pequeño menú de bienvenida*/
{
   printf("--->Conversor Julios <-> Electron-Voltios\n");
}

void limpiarPantalla (void) /*Limpia la pantalla de la consola del sistema*/
{
   system("cls");
}

Estas creando una variable tipo char para almacenar un numero

Código (cpp) [Seleccionar] Expandir

unsigned char eleccion = 0; /*Valor por defecto en 0*/

Esta cosa rara...

Código (cpp) [Seleccionar] Expandir

scanf("%hhu", &eleccion);

En todos los scanf y algunos printf pones esto, si lo que quieres es coger o mostrar solo un decimal, se pone con punto

Código (cpp) [Seleccionar] Expandir

scanf("%lf", &J);

printf("%lg J = %lg Ev\n", J, Ev);

pero la simplicidad es buena para aprender

El código es muy enrevesado para ser simple y poder aprender

Pero bueno, lo que te digo de la función main es esto, quizás te funciona mejor este codigo

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>

#define CargaElectron 1.6e-19

float Julios_EV(float Julios);  //Realiza la conversion de Julios a Electron-Voltios
float EV_Julios(float EV);      //Realiza la conversion de Electron-Voltios a Julios

int main ()
{
   int Opcion;

   float Valor, Resultado;

   printf("Conversor Julios <-> Electron-Voltios\n");

   do
   {

       printf("\n  [1] Julios -> Electron-Voltios"
              "\n  [2] Electron-Voltios -> Julios"
              "\n  [3] Salir");

       printf("\n\nEscoje una opcion: ");
       scanf("%d", &Opcion);

       switch(Opcion)
       {
           case 1:
           {
               printf("\nCuantos Julios deseas convertir: ");
               scanf("%f",&Valor);
               Resultado = Julios_EV(Valor);

               printf("\n\n%.2f Julios son %.2f EV\n",Valor,Resultado);

               break;

           }
           case 2:
           {
               printf("\nCuantos EV deseas convertir: ");
               scanf("%f",&Valor);
               Resultado = EV_Julios(Valor);

               printf("\n\n%.2f EV son %.2f Julios\n",Valor,Resultado);

               break;

           }
           case 3:
           {
               break;
           }
           default:
           {
               printf("\nOpcion Incorrecta!\n"); //Error
               break; //Salimos
           }
       }
   }while(Opcion!=3);

   return 0;
}

float Julios_EV(float Julios)  //Realiza la conversion de Julios a Electron-Voltios
{

   float EV;

   EV = Julios/CargaElectron;

   return EV;
}

float EV_Julios(float EV)      //Realiza la conversion de Electron-Voltios a Julios
{

   float Julios;

   Julios = EV * CargaElectron;

   return Julios;
}

Estoy seguro de que se puede optimizar mucho mas, pero para que te hagas una idea.

Saludos


Modificado

Revisa estas dos funciones, los valores que dan los printf, a ver si ves el error

Código (cpp) [Seleccionar] Expandir

void J_Ev (void) /*Realiza la conversion de Julios a Electron-Voltios*/
{
   /*Declaración de variables*/
   double J;
   double Ev;
   const double cargaElectron = 1.6e-19;

   /*Trámites con el usuario*/
   printf("Julios a convertir: ");
   scanf("%lf", &J);
   limpiarBuffer();
   printf("Convirtiendo...\n");

   /*Conversion*/
   Ev = J/cargaElectron;
   printf("%lg J = %lg Ev\n", J, Ev);
}

void Ev_J (void) /*Realiza la conversion de Electron-Voltios a Julios*/
{
   /*Declaración de variables*/
   double J;
   double Ev;
   const double cargaElectron = 1.6e-19;

   /*Trámites con el usuario*/
   printf("Electron-Voltios a convertir: ");
   scanf("%lf", &Ev);
   limpiarBuffer();
   printf("Convirtiendo...\n");

   /*Conversion*/
   J = Ev*cargaElectron;
   printf("%lg Ev = %lg J\n", J, Ev);
}

Pista, el último printf

Modificado 2

Por cierto...

Código (cpp) [Seleccionar] Expandir

const double cargaElectron = 1.6e-19;

Se declaran al inicio

Saludos

[Álvaro G. Tenorio]

¿Qué problema hay con el main();?

Voy a modificar cuando pueda el código para unir la función menu(); y sentidoConversion(); ya me di cuenta de que es inútil tanta división de funciones.

Asimismo eliminaré las funciones de limpiarBuffer(); y limpiarPantalla(); Pero mi pregunta es: ¿si a estas funciones les pusiera un inline delante a efectos de código compilado no tendrían el mismo rendimiento?

Uso un unsigned char para guardar números pequeños del 0 al 255. En cuanto al %hhu es el modificador de formato de scanf para variables de unsigned char

Pongo lo del %lg no para que sólo muestre un decimal sino para que sólo muestre los decimales significativos (los que no son 0).

Quizá si sea enrevesado por todos los comentarios y una dicisión absurda en infinitas funciones inútiles, pero, ¿no es mejor dividir el programa en funciones para que el main(); quede escueto? al menos eso me recomendaron a mi, pues yo antes solía programar unos main(); elefantiásicos...

Ya vi el error de los printf(); cosas de copiar y pegar, lo modificaré en cuanto pueda, muchas gracias, sino se queda ahí...

Por último que me recomiendas: declarar las constantes como globales al principio del código tal que así:

Código (cpp) [Seleccionar] Expandir

const double cargaElectron = 1.6e-19;

o por el contrario definirlas como constantes con una directiva al preprocesador:

Código (cpp) [Seleccionar] Expandir

#define cargaElectron 1.6e-19L

[ivancea96]

Lo de las constantes, yo creo que un #define iría mejor.

En cuanto a lo de limpiarPantalla y buffer, hazlo como quieras. inline es practicamente lo mismo que poner "system("cls");". En cambio, me parece más limpio ponerlo con el system. ahorrarte funciones.

Por mi parte, algo tan sencillo, lo haría sin funciones xD un While(1) o un goto para mantener el ciclo infinito, y listo xd

Por cierto: la función reinicio, llama a main. Y main, llama a la función reinicio. Espero que me entiendas. Esa función reinicio se llama constantemente, y nunca se llega a cerrar hasta que le des a "NO". Suponiendo que hagas 20 calculos con el programa, tendrías abiertas 20 funciones reinicio y otro tanto de main.

Si es un ejercicio, bien, pero si es un programa, yo me lo replantearía. Yo me desharía de la función "reinicio", y lo metería en el main. Si quieres mantener la función reinicio, yo haría que retorne un valor, el valor "1" o "2", y que en main, cierre el bucle si es "2".

Pero tu verás

[eferion]

Lo de las constantes, yo creo que un #define iría mejor.

Depende. Usar constantes tiene sus ventajas:
* Type-safe
* Se puede usar como parámetro en funciones que requieran el paso de punteros y/o referencias.
* Crea símbolos en depuración, lo que facilita el proceso de debug.

Define también tiene alguna ventaja sobre const... pero en c++ lo más lógico y recomendable es usar const.

[0xDani]

Sobre la función limpiarPantalla(), ya he puesto esto varias veces: puedes hacerla portable mediante el uso del preprocesador.

Código (cpp) [Seleccionar] Expandir


inline void limpiarPantalla()
{
#ifdef __unix__ /* Estamos en un Unix[-like] */
system("clear");
#elif defined _WIN32 /* Windows */
system("cls");
#else
#warning limpiarPantalla not supported
#endif
}


[ivancea96]

Depende. Usar constantes tiene sus ventajas:

Me refiero en ese código no pasa referencias.

[Álvaro G. Tenorio]

Si te digo la verdad no se me había ocurrido eso de que la función seguía activa con su correspondiente gasto de memoria, ya estoy modificando el código, en cuanto pueda lo copio y lo modifico aquí.