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

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Calculadora básica con interfaz [Win API][Terminada]
0 Usuarios y 2 Visitantes están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Calculadora básica con interfaz [Win API][Terminada]  (Leído 6,182 veces)
Alien-Z

Desconectado Desconectado

Mensajes: 177


C++ Programmer


Ver Perfil
Calculadora básica con interfaz [Win API][Terminada]
« en: 17 Septiembre 2011, 14:35 pm »

Bueno, finalmente he acabado una calculadora muy sencilla con interfaz poniendo en práctica lo que he aprendido de la API de Windows; la cuelgo aqui por si le sirve a alguien de ejemplo (todas las funciones y códigos van comentados).

main.cpp:

Código
  1. #include <windows.h>
  2. #include <tchar.h>
  3. #include <stdio.h>
  4. #include <math.h>
  5.  
  6. //ID´s
  7. enum {ID_LABEL, ID_EDIT, ID_BOTONIGUAL, ID_BOTONRESET, ID_BOTONRESET2, ID_BOTONSUMAR, ID_BOTONRESTAR, ID_BOTONMULTIPLICAR, ID_BOTONDIVIDIR, ID_BOTONPORCENTAJE, ID_BOTONPOTENCIA, ID_BOTONRAIZ, ID_BOTONPI, ID_BOTONCOMA, ID_BOTONSIGNO, ID_BOTONCERO, ID_BOTON1, ID_BOTON2, ID_BOTON3, ID_BOTON4, ID_BOTON5, ID_BOTON6, ID_BOTON7, ID_BOTON8, ID_BOTON9};
  8.  
  9.  
  10. //Prototipos
  11. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  12.  
  13. void imprimirEdit (int i);                                                  //Funcion que concatena los numeros al hacer clic en los botones
  14. double calcular (double primer_num, double segundo_num, int operacion);     //Funcion que realiza las operaciones
  15.  
  16. HINSTANCE estancia;
  17. HWND label;
  18. HWND edit;
  19. //Iconos
  20. HICON iconoPotencia;
  21. HICON iconoRaiz;
  22. HICON iconoPi;
  23. //Botones
  24. HWND boton1;
  25. HWND boton2;
  26. HWND boton3;
  27. HWND boton4;
  28. HWND boton5;
  29. HWND boton6;
  30. HWND boton7;
  31. HWND boton8;
  32. HWND boton9;
  33. HWND boton0;
  34. HWND botonComa;
  35. HWND botonSigno;
  36. HWND botonIgual;
  37. HWND botonReset;
  38. HWND botonReset2;
  39. HWND botonSumar;
  40. HWND botonRestar;
  41. HWND botonMultiplicar;
  42. HWND botonDividir;
  43. HWND botonPorcentaje;
  44. HWND botonPotencia;
  45. HWND botonRaiz;
  46. HWND botonPi;
  47.  
  48.  
  49. char szClassName[ ] = "CodeBlocksWindowsApp";
  50.  
  51. int WINAPI WinMain (HINSTANCE hThisInstance,
  52.                     HINSTANCE hPrevInstance,
  53.                     LPSTR lpszArgument,
  54.                     int nCmdShow)
  55. {
  56.    HWND hwnd;               /* This is the handle for our window */
  57.    MSG messages;            /* Here messages to the application are saved */
  58.    WNDCLASSEX wincl;        /* Data structure for the windowclass */
  59.  
  60.    estancia = hThisInstance;
  61.  
  62.    /* The Window structure */
  63.    wincl.hInstance = hThisInstance;
  64.    wincl.lpszClassName = szClassName;
  65.    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  66.    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  67.    wincl.cbSize = sizeof (WNDCLASSEX);
  68.  
  69.    /* Use default icon and mouse-pointer */
  70.    wincl.hIcon = LoadIcon (estancia, "ICONO");
  71.    wincl.hIconSm = LoadIcon (estancia, "ICONO");
  72.    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  73.    wincl.lpszMenuName = NULL;                 /* No menu */
  74.    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  75.    wincl.cbWndExtra = 0;                      /* structure or the window instance */
  76.  
  77.    //Cargamos los iconos de los botones
  78.    iconoPotencia = LoadIcon (estancia, "POTENCIA");
  79.    iconoRaiz = LoadIcon (estancia, "RAIZ");
  80.    iconoPi = LoadIcon (estancia, "PI");
  81.  
  82.    //Color de fondo de la aplicacion
  83.    wincl.hbrBackground = (HBRUSH) CreateSolidBrush (RGB(88, 145, 192));
  84.  
  85.    if (!RegisterClassEx (&wincl))
  86.        return 0;
  87.  
  88.    hwnd = CreateWindowEx (
  89.           0,                   /* Extended possibilites for variation */
  90.           szClassName,         /* Classname */
  91.           "Calculadora by Alien-Z",
  92.           WS_OVERLAPPEDWINDOW, /* default window */
  93.           CW_USEDEFAULT,       /* Windows decides the position */
  94.           CW_USEDEFAULT,       /* where the window ends up on the screen */
  95.           300,                 /* The programs width */
  96.           300,                 /* and height in pixels */
  97.           HWND_DESKTOP,        /* The window is a child-window to desktop */
  98.           NULL,                /* No menu */
  99.           hThisInstance,       /* Program Instance handler */
  100.           NULL                 /* No Window Creation data */
  101.           );
  102.  
  103.    /* Make the window visible on the screen */
  104.    ShowWindow (hwnd, nCmdShow);
  105.  
  106.    /* Run the message loop. It will run until GetMessage() returns 0 */
  107.    while (GetMessage (&messages, NULL, 0, 0))
  108.    {
  109.        /* Translate virtual-key messages into character messages */
  110.        TranslateMessage(&messages);
  111.        /* Send message to WindowProcedure */
  112.        DispatchMessage(&messages);
  113.    }
  114.  
  115.    /* The program return-value is 0 - The value that PostQuitMessage() gave */
  116.    return messages.wParam;
  117. }
  118.  
  119.  
  120. /*  This function is called by the Windows function DispatchMessage()  */
  121.  
  122. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  123. {
  124.    PAINTSTRUCT ps;
  125.    HDC hdc;
  126.    TCHAR greeting[] = _T("Alien-Z");
  127.    COLORREF color1 = RGB (192, 192, 192);
  128.  
  129.    //Variables
  130.    char cadenaEditMain [31];
  131.    static int operacion;
  132.    static double primer_num, segundo_num, resultado, signo;
  133.  
  134.  
  135.    switch (message)
  136.    {
  137.        case WM_CREATE:
  138.        {
  139.            //Elementos de la calculadora
  140.            label = CreateWindow ("Static", NULL, BS_CENTER | WS_CHILD | WS_VISIBLE, 20, 20, 250, 25, hwnd, 0, estancia, 0);
  141.            edit = CreateWindowEx (WS_EX_CLIENTEDGE, "edit", 0, ES_RIGHT | ES_NUMBER | WS_BORDER | WS_CHILD | WS_VISIBLE, 20, 50, 250, 25, hwnd, (HMENU)ID_EDIT, estancia, 0);
  142.  
  143.            boton1 = CreateWindow ("Button", "1", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
  144.            boton2 = CreateWindow ("Button", "2", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 90, 40, 25, hwnd, (HMENU) ID_BOTON2, estancia, 0);
  145.            boton3 = CreateWindow ("Button", "3", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 90, 40, 25, hwnd, (HMENU) ID_BOTON3, estancia, 0);
  146.            boton4 = CreateWindow ("Button", "4", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 120, 40, 25, hwnd, (HMENU) ID_BOTON4, estancia, 0);
  147.            boton5 = CreateWindow ("Button", "5", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 120, 40, 25, hwnd, (HMENU) ID_BOTON5, estancia, 0);
  148.            boton6 = CreateWindow ("Button", "6", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 120, 40, 25, hwnd, (HMENU) ID_BOTON6, estancia, 0);
  149.            boton7 = CreateWindow ("Button", "7", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 150, 40, 25, hwnd, (HMENU) ID_BOTON7, estancia, 0);
  150.            boton8 = CreateWindow ("Button", "8", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 150, 40, 25, hwnd, (HMENU) ID_BOTON8, estancia, 0);
  151.            boton9 = CreateWindow ("Button", "9", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 150, 40, 25, hwnd, (HMENU) ID_BOTON9, estancia, 0);
  152.            boton0 = CreateWindow ("Button", "0", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 180, 40, 25, hwnd, (HMENU) ID_BOTONCERO, estancia, 0);
  153.            botonComa = CreateWindow ("Button", ",", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 180, 40, 25, hwnd, (HMENU) ID_BOTONCOMA, estancia, 0);
  154.            botonSigno = CreateWindow ("Button", "+/-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 180, 40, 25, hwnd, (HMENU) ID_BOTONSIGNO, estancia, 0);
  155.            botonSumar = CreateWindow ("Button", "+", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 90, 40, 25, hwnd, (HMENU) ID_BOTONSUMAR, estancia, 0);
  156.            botonRestar = CreateWindow ("Button", "-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 120, 40, 25, hwnd, (HMENU) ID_BOTONRESTAR, estancia, 0);
  157.            botonMultiplicar = CreateWindow ("Button", "*", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 150, 40, 25, hwnd, (HMENU) ID_BOTONMULTIPLICAR, estancia, 0);
  158.            botonDividir = CreateWindow ("Button", "/", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 180, 40, 25, hwnd, (HMENU) ID_BOTONDIVIDIR, estancia, 0);
  159.            botonPorcentaje = CreateWindow ("Button", "%", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 90, 40, 25, hwnd, (HMENU) ID_BOTONPORCENTAJE, estancia, 0);
  160.            botonPotencia = CreateWindow ("Button", "x ²", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 120, 40, 25, hwnd, (HMENU) ID_BOTONPOTENCIA, estancia, 0);
  161.            botonRaiz = CreateWindow ("Button", "Raiz", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 150, 40, 25, hwnd, (HMENU) ID_BOTONRAIZ, estancia, 0);
  162.            botonPi = CreateWindow ("Button", "Pi", BS_ICON | BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 180, 40, 25, hwnd, (HMENU) ID_BOTONPI, estancia, 0);
  163.            botonIgual = CreateWindow ("Button", "=", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 220, 40, 25, hwnd, (HMENU) ID_BOTONIGUAL, estancia, 0);
  164.            botonReset = CreateWindow ("Button", "C", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET, estancia, 0);
  165.            botonReset2 = CreateWindow ("Button", "CE", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET2, estancia, 0);
  166.  
  167.            //Cambiar fuente de letra del lablel
  168.            static HFONT hFont = CreateFont (16, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, VARIABLE_PITCH | FF_SWISS, "Comic Sans MS");
  169.            SendMessage(label, WM_SETFONT, (WPARAM) hFont, true);
  170.  
  171.            //Enviar iconos a los botones
  172.            SendMessage(botonPotencia, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPotencia);
  173.            SendMessage(botonRaiz, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoRaiz);
  174.            SendMessage(botonPi, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPi);
  175.  
  176.            //Bloquear el boton "maximizar"
  177.            DWORD dwStyle = (DWORD)GetWindowLong(hwnd, GWL_STYLE);
  178.            dwStyle &= ~WS_MAXIMIZEBOX;
  179.            SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
  180.            RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);
  181.  
  182.            //Bloquear la opcion de cambiarle el tamaño a la ventana
  183.            dwStyle &= ~WS_SIZEBOX;
  184.            SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
  185.            RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);
  186.        }
  187.  
  188.        case WM_COMMAND:
  189.        {
  190.            switch (wParam)
  191.            {
  192.                case ID_BOTON1:                  //Al presionar el boton 1 se llama a la funcion "imprimirEdit" y se le envia el valor "1" que es lo que queremos que se concatene a lo que ya haya en el edit
  193.                {
  194.                    imprimirEdit (1);
  195.                    break;
  196.                }
  197.                case ID_BOTON2:
  198.                {
  199.                    imprimirEdit (2);
  200.                    break;
  201.                }
  202.                case ID_BOTON3:
  203.                {
  204.                    imprimirEdit (3);
  205.                    break;
  206.                }
  207.                case ID_BOTON4:
  208.                {
  209.                    imprimirEdit(4);
  210.                    break;
  211.                }
  212.                case ID_BOTON5:
  213.                {
  214.                    imprimirEdit(5);
  215.                    break;
  216.                }
  217.                case ID_BOTON6:
  218.                {
  219.                    imprimirEdit(6);
  220.                    break;
  221.                }
  222.                case ID_BOTON7:
  223.                {
  224.                    imprimirEdit(7);
  225.                    break;
  226.                }
  227.                case ID_BOTON8:
  228.                {
  229.                    imprimirEdit(8);
  230.                    break;
  231.                }
  232.                case ID_BOTON9:
  233.                {
  234.                    imprimirEdit(9);
  235.                    break;
  236.                }
  237.                case ID_BOTONCERO:
  238.                {
  239.                    imprimirEdit(0);
  240.                    break;
  241.                }
  242.                case ID_BOTONCOMA:
  243.                {
  244.                    GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
  245.                    if (strstr (cadenaEditMain, ".") == NULL)        //Analizamos "cadenaEditMain" y si no posee una coma se ejecuta lo que hay dentro del if (en caso de que ya tenga una coma no hace nada)
  246.                    {
  247.                        strcat (cadenaEditMain, ".");                //Se le añade una coma a lo que hay en "CadenaEditMain"
  248.                        SetWindowText (edit, cadenaEditMain);        //Se imprime el nuevo numero en el edit
  249.                    }
  250.                    break;
  251.                }
  252.                case ID_BOTONSIGNO:                                  //Boton que cambia el signo del numero
  253.                {
  254.                    GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
  255.                    signo = atof (cadenaEditMain);                   //Transforma la cadena obtenida en un double y lo guarda en "signo"
  256.                    signo *= -1;                                     //Se multiplica el numero por -1 (si es positivo se quedara negativo, y viceversa)
  257.                    sprintf (cadenaEditMain, "%f", signo);           //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
  258.                    SetWindowText (edit, cadenaEditMain);            //Se imprime el nuevo numero en el edit
  259.                    break;
  260.                }
  261.                case ID_BOTONSUMAR:
  262.                {
  263.                    operacion = 1;                                    //Cambia el valor de "operacion" para indicar que se va a sumar
  264.                    GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
  265.                    primer_num = atof (cadenaEditMain);               //Transforma la cadena obtenida en un double y lo guarda en "primer_num"
  266.                    SetWindowText (edit, "");                         //Limpia el edit
  267.                    break;
  268.                }
  269.                case ID_BOTONRESTAR:
  270.                {
  271.                    operacion = 2;                                    //Cambia el valor de "operacion" para indicar que se va a restar
  272.                    GetWindowText (edit, cadenaEditMain, 30);
  273.                    primer_num = atof (cadenaEditMain);
  274.                    SetWindowText (edit, "");
  275.                    break;
  276.                }
  277.                case ID_BOTONMULTIPLICAR:
  278.                {
  279.                    operacion = 3;                                    //Cambia el valor de "operacion" para indicar que se va a multiplicar
  280.                    GetWindowText (edit, cadenaEditMain, 30);
  281.                    primer_num = atof (cadenaEditMain);
  282.                    SetWindowText (edit, "");
  283.                    break;
  284.                }
  285.                case ID_BOTONDIVIDIR:
  286.                {
  287.                    operacion = 4;                                    //Cambia el valor de "operacion" para indicar que se va a dividir
  288.                    GetWindowText (edit, cadenaEditMain, 30);
  289.                    primer_num = atof (cadenaEditMain);
  290.                    SetWindowText (edit, "");
  291.                    break;
  292.                }
  293.                case ID_BOTONPORCENTAJE:
  294.                {
  295.                    operacion = 5;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar el porcentaje
  296.                    GetWindowText (edit, cadenaEditMain, 30);
  297.                    primer_num = atof (cadenaEditMain);
  298.                    SetWindowText (edit, "");
  299.                    break;
  300.                }
  301.                case ID_BOTONPOTENCIA:
  302.                {
  303.                    operacion = 6;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar una potencia
  304.                    GetWindowText (edit, cadenaEditMain, 30);
  305.                    primer_num = atof (cadenaEditMain);
  306.                    SetWindowText (edit, "");
  307.                    SetWindowText (label, "¿A cuánto está elevado el número?");
  308.                    break;
  309.                }
  310.                case ID_BOTONRAIZ:
  311.                {
  312.                    operacion = 7;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar la raiz
  313.                    GetWindowText (edit, cadenaEditMain, 30);
  314.                    primer_num = atof (cadenaEditMain);
  315.                    SetWindowText (edit, "");
  316.                    SetWindowText (label, "¿A cuánto está elevada la raiz?");
  317.                    break;
  318.                }
  319.                case ID_BOTONPI:
  320.                {
  321.                    SetWindowText (edit, "3.141592653589793");        //Imprime en el edit el valor de PI
  322.                    break;
  323.                }
  324.                case ID_BOTONIGUAL:
  325.                {
  326.                    GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
  327.                    segundo_num = atof (cadenaEditMain);              //Transforma la cadena obtenida en un double y lo guarda en "segundo_num"
  328.                    resultado = calcular (primer_num, segundo_num, operacion); //El resultado se obtiene apartir de la funcion "calcular", a esta funcion se le envian las variables "primer_num", "segundo_num" y "operacion"
  329.                    sprintf (cadenaEditMain, "%f", resultado);        //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
  330.                    SetWindowText (edit, cadenaEditMain);             //Se imprime en el edit la cadena donde se encuentra el resultado
  331.                    //Reseteamos las variables
  332.                    primer_num = 0;
  333.                    segundo_num = 0;
  334.                    operacion = 0;
  335.                    break;
  336.                }
  337.                case ID_BOTONRESET:                                  //Boton que limpia las variables y datos para calcular de nuevo
  338.                {
  339.                    primer_num = 0;
  340.                    segundo_num = 0;
  341.                    operacion = 0;
  342.                    SetWindowText (edit, "");
  343.                    SetWindowText (label, "");
  344.                    break;
  345.                }
  346.                case ID_BOTONRESET2:                                 //Boton que borra solo el ultimo numero introducido
  347.                {
  348.                    segundo_num = 0;
  349.                    SetWindowText (edit, "");
  350.                    break;
  351.                }
  352.  
  353.                break;
  354.            }
  355.            break;
  356.        }
  357.  
  358.        case WM_PAINT:
  359.        {
  360.            hdc = BeginPaint(hwnd, &ps);
  361.            SetBkColor (hdc, RGB(88, 145, 192));
  362.            SetTextColor (hdc, color1);
  363.            TextOut(hdc, 230, 240, greeting, _tcslen(greeting));
  364.            EndPaint (hwnd, &ps);
  365.            break;
  366.        }
  367.  
  368.        case WM_DESTROY:
  369.            PostQuitMessage (0);
  370.            break;
  371.        default:
  372.            return DefWindowProc (hwnd, message, wParam, lParam);
  373.    }
  374.  
  375.    return 0;
  376. }
  377.  
  378. void imprimirEdit (int i)                        //Funcion que concatena los numeros al hacer clic en los botones
  379. {
  380.    char cadenaEdit [31];                        //Variable donde se guardara lo que hay en el edit (no es la misma variable que cadenaEditMain)
  381.    char numero [3];                             //Variable donde se guardara el numero de la tecla presionada
  382.    sprintf (numero, "%i", i);                   //Se transforma el numero (i) del tipo entero a una cadena
  383.  
  384.    GetWindowText (edit, cadenaEdit, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEdit"
  385.    strcat (cadenaEdit, numero);                 //Se une lo que hay en "CadenaEdit" y lo que hay en "numero" (es decir, se une lo que habia en el edit y el numero de la tecla presionada) y se queda guardada la nueva cifra en "cadenaEdit"
  386.    SetWindowText (edit, cadenaEdit);            //Se imprime el nuevo numero en el edit
  387. }
  388.  
  389. double calcular (double primer_num, double segundo_num, int operacion)   //Funcion que realiza las operaciones
  390. {
  391.    double resultado;                                                    //Variable donde se guardara el resultado (sera lo que se retorne)
  392.  
  393.    switch (operacion)                                                   //Ver lo que hay en la variable "operacion"
  394.    {
  395.        case 1:                                                          //En caso de que sea "1" se suma el primer numero al segundo
  396.        {
  397.            resultado = primer_num + segundo_num;
  398.            break;
  399.        }
  400.        case 2:                                                          //En caso de que sea "2" se le resta el segundo numero al primero
  401.        {
  402.            resultado = primer_num - segundo_num;
  403.            break;
  404.        }
  405.        case 3:                                                          //En caso de que sea "3" se multiplica el primer numero por el segundo
  406.        {
  407.            resultado = primer_num * segundo_num;
  408.            break;
  409.        }
  410.        case 4:                                                          //En caso de que sea "4" se divide el primer numero entre el segundo
  411.        {
  412.            resultado = primer_num / segundo_num;
  413.            break;
  414.        }
  415.        case 5:                                                          //En caso de que sea "5" se haya el tanto por cierto (primer numero) del segundo numero
  416.        {
  417.            resultado = (primer_num * segundo_num) / 100;
  418.            break;
  419.        }
  420.        case 6:                                                          //En caso de que sea "6" se obtiene la potencia del primer numero elevado al segundo
  421.        {
  422.            resultado = pow (primer_num, segundo_num);
  423.            break;
  424.        }
  425.        case 7:                                                          //En caso de que sea "7" se obtiene la raiz del primer numero (el segundo define si dicha raiz es cubica, cuadrada...)
  426.        {
  427.            resultado = pow (primer_num, 1/segundo_num);
  428.            break;
  429.        }
  430.        default:                                                         //Si no se realiza ninguna operacion se imprime en el label un mensaje, con esto sabriamos si ha habido algun error
  431.        {
  432.            SetWindowText (label, "No se ha realizado ninguna operacion.");
  433.            break;
  434.        }
  435.    }
  436.  
  437.    SetWindowText (label, "");                                           //Limpiamos el label
  438.    return resultado;                                                    //Devuelve el resultado
  439. }
  440.  

recursos.rc:

Código
  1. ICONO ICON "icono.ico"
  2. POTENCIA ICON "potencia.ico"
  3. RAIZ ICON "raiz.ico"
  4. PI ICON "pi.ico"
  5.  

Iconos (no he encontrado ningún servidor para subir .ico que acepte fondo transparente asi que he optado por MU): http://www.megaupload.com/?d=ZMPELBPE

Notas:
-Los iconos deben estar dentro de la carpeta del proyecto.
-Aun no he solucionado un pequeño inconveniente y es que solo opera con los dos últimos números introducidos, por ejemplo, si presionas 2+2*5 el resultado será 10 porque la última operación es 2*5, pero si después de cada cálculo presionas el botón igual hará todas las operaciones que le mandes sin problema.
-La función del botón "porcentaje" suele variar según la calculadora, en este caso hayas el X por ciento de Y, por ejemplo, 50 % 10 = 5 (el 50 por ciento de 10 es 5).


Espero que le sirva a alguien. Saludos.


« Última modificación: 17 Septiembre 2011, 21:28 pm por Alien-Z » En línea

тαптяα


Desconectado Desconectado

Mensajes: 1.151


Sic utere tuo ut alienum non laeda


Ver Perfil WWW
Re: Calculadora básica con interfaz [Win API][Terminada]
« Respuesta #1 en: 26 Septiembre 2011, 14:52 pm »

Esta muy bien, para los que empiezan con WINAPI.

Aunque ya te dijeron que mejor usa clases así no tendrás el code tan largo.


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Calculadora básica by swik
Scripting
.:Swik:. 1 2,830 Último mensaje 20 Abril 2010, 02:49 am
por BloodyDark
Problema con calculadora basica!!!!!!!!!!
Programación C/C++
prometheus48 4 2,969 Último mensaje 9 Octubre 2011, 14:48 pm
por prometheus48
Calculadora basica en visual basic
.NET (C#, VB.NET, ASP)
Sarachan 5 5,262 Último mensaje 5 Diciembre 2011, 14:09 pm
por Sarachan
[SRC] [javascript] Calculadora básica estilo Windows
Desarrollo Web
Psyke1 0 3,195 Último mensaje 16 Octubre 2012, 11:42 am
por Psyke1
Ayuda con calculadora básica en C
Programación C/C++
wazausky 2 2,239 Último mensaje 12 Marzo 2013, 03:03 am
por rir3760
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines