Temas

Buenas tardes:

Estoy desarrollando en Java un gestor de correos y necesito conectarme a un servidor de correos para el envío/recepción de los mensajes.

He hecho envíos con gmail y hotmail pero sé que te ponen restricciones en cuanto a la cantidad de mensajes que puedes mandar en un periodo de tiempo antes de que te bloqueen la cuenta. La aplicación es con fines comerciales así que necesito poder mandarlos a miles de usuarios.

Mi primera opción ha sido añadir como destinatarios a todos los receptores, pero gmail permite como máximo 500 y Hotmail 100. La segunda idea ha sido crear un bucle y mandar el mensaje varias veces añadiendo en cada envío a 100 destinatarios, pero como he comentado antes esto funciona solo durante un periodo de tiempo antes de que gmail te bloquee la cuenta.

¿Conocéis algún servidor de correos que ofrezca una API o un modo de comunicación con aplicaciones Java y dé mayor libertad en cuanto al envío masivo de e-mails?

Un saludo.

Buenas tardes:

Un pequeño comercio me ha encargado el desarrollo de una aplicación personalizada para el envío de correos. Mi primera opción de momento es Java, ya que tiene librerías estándar que ofrecen la mayoría de operaciones que voy a necesitar, y con las que he trabajado en otro momento.

Aún así, me atrae la idea de desarrollarlo en C++, pero no encuentro la luz en cuanto a librerías y referencias. Sé que con QT se pueden enviar e-mails de manera muy sencilla, pero necesito otras operaciones:

Descargar y subir lista de contactos de algún servidor (Gmail, hotmail, etc.)
Subir los correos borrador.
Enviar correos con imágenes insertadas en el mensaje (no adjuntas).
Enviar ficheros adjuntos (un pdf o un zip).

¿Alguien conoce alguna librería o API que se acerque?.

Gracias. Un saludo.

Esta semana comienza la expansión de nombres de dominios. En contra de la voluntad de algunas grandes empresas, a partir del jueves 12 de enero cualquier persona o empresa podrá registrar cualquier palabra como extensión de una página web.

En la actualidad hay alrededor de 22 tipos de dominios de primer nivel como .com o .org, además de los códigos de países como .es para España. Las empresas creen que ya es suficiente, y 40 granes corporaciones, como por ejemplo Coca Cola, se han quejado de que con la expansión del dominio se elevan los costes y aumenta el riesgo de fraude y suplantación.

Este podría suponer uno de los mayores cambios en Internet desde su creación hace décadas, y estará coordinado por ICANN (Internet Corporation for Assigned Names and Numbers), que es una organización sin ánimo de lucro que opera a nivel internacional, y es responsable de asignar espacio de direcciones numéricas de protocolo de Internet (IP), así como la administración del sistema de nombres de dominio de primer nivel genéricos (gTLD) y de códigos de países (ccTLD).

El lanzamiento de los llamados "puntos de la marca" es el último gran cambio en las estrictas normas que rigen la nomenclatura de Internet desde el lanzamiento de .com en 1985. El mayor cambio reciente se produjo el año pasado cuando se puso en marcha el .xxx para dar a los sitios web para adultos su propio espacio en Internet. Este dominio cuenta con 250.000 sitios web en nueve meses.

Sin embargo, este nuevo cambio lleva la personalización de las páginas web a un nuevo nivel. De esta forma, muchas marcas o instituciones ven en ello muchas posibilidades, aunque otras ven problemas de suplantación de identidad. Proteger la marca les podría costar millones.

Los solicitantes tienen hasta el 12 de abril para inscribirse, y después tendrá lugar un proceso de evaluación de ocho meses. Los primeros sitios de nivel superior de dominio se espera que sean efectivos para 2013. Mientras tanto, ICANN espera que haya hasta 4.000 aplicaciones.

Fuente: http://www.20minutos.es/noticia/1270649/0/palabras/dominios/internet/

[Espero que le sirva a alguien. Saludos.]

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

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <math.h>

//ID´s
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};


//Prototipos
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

void imprimirEdit (int i);                                                  //Funcion que concatena los numeros al hacer clic en los botones
double calcular (double primer_num, double segundo_num, int operacion);     //Funcion que realiza las operaciones

HINSTANCE estancia;
HWND label;
HWND edit;
//Iconos
HICON iconoPotencia;
HICON iconoRaiz;
HICON iconoPi;
//Botones
HWND boton1;
HWND boton2;
HWND boton3;
HWND boton4;
HWND boton5;
HWND boton6;
HWND boton7;
HWND boton8;
HWND boton9;
HWND boton0;
HWND botonComa;
HWND botonSigno;
HWND botonIgual;
HWND botonReset;
HWND botonReset2;
HWND botonSumar;
HWND botonRestar;
HWND botonMultiplicar;
HWND botonDividir;
HWND botonPorcentaje;
HWND botonPotencia;
HWND botonRaiz;
HWND botonPi;


char szClassName[ ] = "CodeBlocksWindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nCmdShow)
{
   HWND hwnd;               /* This is the handle for our window */
   MSG messages;            /* Here messages to the application are saved */
   WNDCLASSEX wincl;        /* Data structure for the windowclass */

   estancia = hThisInstance;

   /* The Window structure */
   wincl.hInstance = hThisInstance;
   wincl.lpszClassName = szClassName;
   wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
   wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
   wincl.cbSize = sizeof (WNDCLASSEX);

   /* Use default icon and mouse-pointer */
   wincl.hIcon = LoadIcon (estancia, "ICONO");
   wincl.hIconSm = LoadIcon (estancia, "ICONO");
   wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
   wincl.lpszMenuName = NULL;                 /* No menu */
   wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
   wincl.cbWndExtra = 0;                      /* structure or the window instance */

   //Cargamos los iconos de los botones
   iconoPotencia = LoadIcon (estancia, "POTENCIA");
   iconoRaiz = LoadIcon (estancia, "RAIZ");
   iconoPi = LoadIcon (estancia, "PI");

   //Color de fondo de la aplicacion
   wincl.hbrBackground = (HBRUSH) CreateSolidBrush (RGB(88, 145, 192));

   if (!RegisterClassEx (&wincl))
       return 0;

   hwnd = CreateWindowEx (
          0,                   /* Extended possibilites for variation */
          szClassName,         /* Classname */
          "Calculadora by Alien-Z",
          WS_OVERLAPPEDWINDOW, /* default window */
          CW_USEDEFAULT,       /* Windows decides the position */
          CW_USEDEFAULT,       /* where the window ends up on the screen */
          300,                 /* The programs width */
          300,                 /* and height in pixels */
          HWND_DESKTOP,        /* The window is a child-window to desktop */
          NULL,                /* No menu */
          hThisInstance,       /* Program Instance handler */
          NULL                 /* No Window Creation data */
          );

   /* Make the window visible on the screen */
   ShowWindow (hwnd, nCmdShow);

   /* Run the message loop. It will run until GetMessage() returns 0 */
   while (GetMessage (&messages, NULL, 0, 0))
   {
       /* Translate virtual-key messages into character messages */
       TranslateMessage(&messages);
       /* Send message to WindowProcedure */
       DispatchMessage(&messages);
   }

   /* The program return-value is 0 - The value that PostQuitMessage() gave */
   return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   PAINTSTRUCT ps;
   HDC hdc;
   TCHAR greeting[] = _T("Alien-Z");
   COLORREF color1 = RGB (192, 192, 192);

   //Variables
   char cadenaEditMain [31];
   static int operacion;
   static double primer_num, segundo_num, resultado, signo;


   switch (message)
   {
       case WM_CREATE:
       {
           //Elementos de la calculadora
           label = CreateWindow ("Static", NULL, BS_CENTER | WS_CHILD | WS_VISIBLE, 20, 20, 250, 25, hwnd, 0, estancia, 0);
           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);

           boton1 = CreateWindow ("Button", "1", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
           boton2 = CreateWindow ("Button", "2", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 90, 40, 25, hwnd, (HMENU) ID_BOTON2, estancia, 0);
           boton3 = CreateWindow ("Button", "3", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 90, 40, 25, hwnd, (HMENU) ID_BOTON3, estancia, 0);
           boton4 = CreateWindow ("Button", "4", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 120, 40, 25, hwnd, (HMENU) ID_BOTON4, estancia, 0);
           boton5 = CreateWindow ("Button", "5", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 120, 40, 25, hwnd, (HMENU) ID_BOTON5, estancia, 0);
           boton6 = CreateWindow ("Button", "6", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 120, 40, 25, hwnd, (HMENU) ID_BOTON6, estancia, 0);
           boton7 = CreateWindow ("Button", "7", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 150, 40, 25, hwnd, (HMENU) ID_BOTON7, estancia, 0);
           boton8 = CreateWindow ("Button", "8", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 150, 40, 25, hwnd, (HMENU) ID_BOTON8, estancia, 0);
           boton9 = CreateWindow ("Button", "9", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 150, 40, 25, hwnd, (HMENU) ID_BOTON9, estancia, 0);
           boton0 = CreateWindow ("Button", "0", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 180, 40, 25, hwnd, (HMENU) ID_BOTONCERO, estancia, 0);
           botonComa = CreateWindow ("Button", ",", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 180, 40, 25, hwnd, (HMENU) ID_BOTONCOMA, estancia, 0);
           botonSigno = CreateWindow ("Button", "+/-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 180, 40, 25, hwnd, (HMENU) ID_BOTONSIGNO, estancia, 0);
           botonSumar = CreateWindow ("Button", "+", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 90, 40, 25, hwnd, (HMENU) ID_BOTONSUMAR, estancia, 0);
           botonRestar = CreateWindow ("Button", "-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 120, 40, 25, hwnd, (HMENU) ID_BOTONRESTAR, estancia, 0);
           botonMultiplicar = CreateWindow ("Button", "*", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 150, 40, 25, hwnd, (HMENU) ID_BOTONMULTIPLICAR, estancia, 0);
           botonDividir = CreateWindow ("Button", "/", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 180, 40, 25, hwnd, (HMENU) ID_BOTONDIVIDIR, estancia, 0);
           botonPorcentaje = CreateWindow ("Button", "%", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 210, 90, 40, 25, hwnd, (HMENU) ID_BOTONPORCENTAJE, estancia, 0);
           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);
           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);
           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);
           botonIgual = CreateWindow ("Button", "=", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 220, 40, 25, hwnd, (HMENU) ID_BOTONIGUAL, estancia, 0);
           botonReset = CreateWindow ("Button", "C", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET, estancia, 0);
           botonReset2 = CreateWindow ("Button", "CE", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 220, 40, 25, hwnd, (HMENU) ID_BOTONRESET2, estancia, 0);

           //Cambiar fuente de letra del lablel
           static HFONT hFont = CreateFont (16, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, VARIABLE_PITCH | FF_SWISS, "Comic Sans MS");
           SendMessage(label, WM_SETFONT, (WPARAM) hFont, true);

           //Enviar iconos a los botones
           SendMessage(botonPotencia, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPotencia);
           SendMessage(botonRaiz, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoRaiz);
           SendMessage(botonPi, BM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM) iconoPi);

           //Bloquear el boton "maximizar"
           DWORD dwStyle = (DWORD)GetWindowLong(hwnd, GWL_STYLE);
           dwStyle &= ~WS_MAXIMIZEBOX;
           SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
           RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);

           //Bloquear la opcion de cambiarle el tamaño a la ventana
           dwStyle &= ~WS_SIZEBOX;
           SetWindowLong(hwnd, GWL_STYLE, (DWORD)dwStyle);
           RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW);
       }

       case WM_COMMAND:
       {
           switch (wParam)
           {
               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
               {
                   imprimirEdit (1);
                   break;
               }
               case ID_BOTON2:
               {
                   imprimirEdit (2);
                   break;
               }
               case ID_BOTON3:
               {
                   imprimirEdit (3);
                   break;
               }
               case ID_BOTON4:
               {
                   imprimirEdit(4);
                   break;
               }
               case ID_BOTON5:
               {
                   imprimirEdit(5);
                   break;
               }
               case ID_BOTON6:
               {
                   imprimirEdit(6);
                   break;
               }
               case ID_BOTON7:
               {
                   imprimirEdit(7);
                   break;
               }
               case ID_BOTON8:
               {
                   imprimirEdit(8);
                   break;
               }
               case ID_BOTON9:
               {
                   imprimirEdit(9);
                   break;
               }
               case ID_BOTONCERO:
               {
                   imprimirEdit(0);
                   break;
               }
               case ID_BOTONCOMA:
               {
                   GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
                   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)
                   {
                       strcat (cadenaEditMain, ".");                //Se le añade una coma a lo que hay en "CadenaEditMain"
                       SetWindowText (edit, cadenaEditMain);        //Se imprime el nuevo numero en el edit
                   }
                   break;
               }
               case ID_BOTONSIGNO:                                  //Boton que cambia el signo del numero
               {
                   GetWindowText (edit, cadenaEditMain, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEditMain"
                   signo = atof (cadenaEditMain);                   //Transforma la cadena obtenida en un double y lo guarda en "signo"
                   signo *= -1;                                     //Se multiplica el numero por -1 (si es positivo se quedara negativo, y viceversa)
                   sprintf (cadenaEditMain, "%f", signo);           //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
                   SetWindowText (edit, cadenaEditMain);            //Se imprime el nuevo numero en el edit
                   break;
               }
               case ID_BOTONSUMAR:
               {
                   operacion = 1;                                    //Cambia el valor de "operacion" para indicar que se va a sumar
                   GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
                   primer_num = atof (cadenaEditMain);               //Transforma la cadena obtenida en un double y lo guarda en "primer_num"
                   SetWindowText (edit, "");                         //Limpia el edit
                   break;
               }
               case ID_BOTONRESTAR:
               {
                   operacion = 2;                                    //Cambia el valor de "operacion" para indicar que se va a restar
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONMULTIPLICAR:
               {
                   operacion = 3;                                    //Cambia el valor de "operacion" para indicar que se va a multiplicar
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONDIVIDIR:
               {
                   operacion = 4;                                    //Cambia el valor de "operacion" para indicar que se va a dividir
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONPORCENTAJE:
               {
                   operacion = 5;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar el porcentaje
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONPOTENCIA:
               {
                   operacion = 6;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar una potencia
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   SetWindowText (label, "¿A cuánto está elevado el número?");
                   break;
               }
               case ID_BOTONRAIZ:
               {
                   operacion = 7;                                    //Cambia el valor de "operacion" para indicar que vamos a hallar la raiz
                   GetWindowText (edit, cadenaEditMain, 30);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   SetWindowText (label, "¿A cuánto está elevada la raiz?");
                   break;
               }
               case ID_BOTONPI:
               {
                   SetWindowText (edit, "3.141592653589793");        //Imprime en el edit el valor de PI
                   break;
               }
               case ID_BOTONIGUAL:
               {
                   GetWindowText (edit, cadenaEditMain, 30);         //Obtiene el numero ingresado en el edit
                   segundo_num = atof (cadenaEditMain);              //Transforma la cadena obtenida en un double y lo guarda en "segundo_num"
                   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"
                   sprintf (cadenaEditMain, "%f", resultado);        //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
                   SetWindowText (edit, cadenaEditMain);             //Se imprime en el edit la cadena donde se encuentra el resultado
                   //Reseteamos las variables
                   primer_num = 0;
                   segundo_num = 0;
                   operacion = 0;
                   break;
               }
               case ID_BOTONRESET:                                  //Boton que limpia las variables y datos para calcular de nuevo
               {
                   primer_num = 0;
                   segundo_num = 0;
                   operacion = 0;
                   SetWindowText (edit, "");
                   SetWindowText (label, "");
                   break;
               }
               case ID_BOTONRESET2:                                 //Boton que borra solo el ultimo numero introducido
               {
                   segundo_num = 0;
                   SetWindowText (edit, "");
                   break;
               }

               break;
           }
           break;
       }

       case WM_PAINT:
       {
           hdc = BeginPaint(hwnd, &ps);
           SetBkColor (hdc, RGB(88, 145, 192));
           SetTextColor (hdc, color1);
           TextOut(hdc, 230, 240, greeting, _tcslen(greeting));
           EndPaint (hwnd, &ps);
           break;
       }

       case WM_DESTROY:
           PostQuitMessage (0);
           break;
       default:
           return DefWindowProc (hwnd, message, wParam, lParam);
   }

   return 0;
}

void imprimirEdit (int i)                        //Funcion que concatena los numeros al hacer clic en los botones
{
   char cadenaEdit [31];                        //Variable donde se guardara lo que hay en el edit (no es la misma variable que cadenaEditMain)
   char numero [3];                             //Variable donde se guardara el numero de la tecla presionada
   sprintf (numero, "%i", i);                   //Se transforma el numero (i) del tipo entero a una cadena

   GetWindowText (edit, cadenaEdit, 30);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEdit"
   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"
   SetWindowText (edit, cadenaEdit);            //Se imprime el nuevo numero en el edit
}

double calcular (double primer_num, double segundo_num, int operacion)   //Funcion que realiza las operaciones
{
   double resultado;                                                    //Variable donde se guardara el resultado (sera lo que se retorne)

   switch (operacion)                                                   //Ver lo que hay en la variable "operacion"
   {
       case 1:                                                          //En caso de que sea "1" se suma el primer numero al segundo
       {
           resultado = primer_num + segundo_num;
           break;
       }
       case 2:                                                          //En caso de que sea "2" se le resta el segundo numero al primero
       {
           resultado = primer_num - segundo_num;
           break;
       }
       case 3:                                                          //En caso de que sea "3" se multiplica el primer numero por el segundo
       {
           resultado = primer_num * segundo_num;
           break;
       }
       case 4:                                                          //En caso de que sea "4" se divide el primer numero entre el segundo
       {
           resultado = primer_num / segundo_num;
           break;
       }
       case 5:                                                          //En caso de que sea "5" se haya el tanto por cierto (primer numero) del segundo numero
       {
           resultado = (primer_num * segundo_num) / 100;
           break;
       }
       case 6:                                                          //En caso de que sea "6" se obtiene la potencia del primer numero elevado al segundo
       {
           resultado = pow (primer_num, segundo_num);
           break;
       }
       case 7:                                                          //En caso de que sea "7" se obtiene la raiz del primer numero (el segundo define si dicha raiz es cubica, cuadrada...)
       {
           resultado = pow (primer_num, 1/segundo_num);
           break;
       }
       default:                                                         //Si no se realiza ninguna operacion se imprime en el label un mensaje, con esto sabriamos si ha habido algun error
       {
           SetWindowText (label, "No se ha realizado ninguna operacion.");
           break;
       }
   }

   SetWindowText (label, "");                                           //Limpiamos el label
   return resultado;                                                    //Devuelve el resultado
}


recursos.rc:

Código (cpp) [Seleccionar] Expandir

ICONO ICON "icono.ico"
POTENCIA ICON "potencia.ico"
RAIZ ICON "raiz.ico"
PI ICON "pi.ico"


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.

Buenas:

He llegado a un punto en el cual, para mejorar la interfaz de un programa, necesito ponerle iconos a los botones, fondos a los edit o static, etc. He encontrado por internet un par de cosas como la función CreateIcon (que me ha dado 500 errores) y esta otra forma:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>

enum {ID_BOTON1};

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

HINSTANCE estancia;
HICON hIcon1;
HWND boton1;

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nCmdShow)
{
   HWND hwnd;               /* This is the handle for our window */
   MSG messages;            /* Here messages to the application are saved */
   WNDCLASSEX wincl;        /* Data structure for the windowclass */

   estancia = hThisInstance;

   /* The Window structure */
   wincl.hInstance = hThisInstance;
   wincl.lpszClassName = szClassName;
   wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
   wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
   wincl.cbSize = sizeof (WNDCLASSEX);

   /* Use default icon and mouse-pointer */
   wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hCursor = LoadCursor (NULL, IDC_ARROW);



   hIcon1 = LoadIcon (estancia, "RAIZ");



   wincl.lpszMenuName = NULL;                 /* No menu */
   wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
   wincl.cbWndExtra = 0;                      /* structure or the window instance */
   /* Use Windows's default colour as the background of the window */
   wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

   /* Register the window class, and if it fails quit the program */
   if (!RegisterClassEx (&wincl))
       return 0;

   /* The class is registered, let's create the program*/
   hwnd = CreateWindowEx (
          0,                   /* Extended possibilites for variation */
          szClassName,         /* Classname */
          "Code::Blocks Template Windows App",       /* Title Text */
          WS_OVERLAPPEDWINDOW, /* default window */
          CW_USEDEFAULT,       /* Windows decides the position */
          CW_USEDEFAULT,       /* where the window ends up on the screen */
          544,                 /* The programs width */
          375,                 /* and height in pixels */
          HWND_DESKTOP,        /* The window is a child-window to desktop */
          NULL,                /* No menu */
          hThisInstance,       /* Program Instance handler */
          NULL                 /* No Window Creation data */
          );

   /* Make the window visible on the screen */
   ShowWindow (hwnd, nCmdShow);

   /* Run the message loop. It will run until GetMessage() returns 0 */
   while (GetMessage (&messages, NULL, 0, 0))
   {
       /* Translate virtual-key messages into character messages */
       TranslateMessage(&messages);
       /* Send message to WindowProcedure */
       DispatchMessage(&messages);
   }

   /* The program return-value is 0 - The value that PostQuitMessage() gave */
   return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)                  /* handle the messages */
   {
       case WM_CREATE:
       {
           boton1 = CreateWindow ("Button", NULL, WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
           SendMessage(boton1, WM_SETICON, (WPARAM) hIcon1, true);
           break;
       }
       case WM_DESTROY:
           PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
           break;
       default:                      /* for messages that we don't deal with */
           return DefWindowProc (hwnd, message, wParam, lParam);
   }

   return 0;
}


Archivo de recursos:

Código (cpp) [Seleccionar] Expandir

RAIZ ICON "raiz.ico"

No me da ningún error y el programa se compila y ejecuta correctamente pero no imprime el icono.

[Saludos.]

Buenas:

Debido a los estudios tengo que comprarme un nuevo portátil asi que pregunto aqui para que me echéis una mano. Fui a la tienda APP de mi ciudad y me recomendaron dos ordenadores:

1- http://www.appinformatica.com/portatiles-pbell.-ts44-hr-232sp-15.6-i32310-4g-500g-nvidia512.php

Datos básicos: 4GB RAM | 500GB disco duro | Procesador i3-2310M | Tarjeta gráfica Nvidia Geforce GT 520M con 512 MB reales.

Precio: 470 € (me parece que está bastante bien de coste con todo lo que lleva).

2- http://www.appinformatica.com/portatiles-portatil-acer-tm5742-i3-350-6gb-640gb-w7hp.php

Datos básicos: 6GB RAM | 640GB disco duro | Procesador i3-350m | Tarjeta gráfica no lo pone.

Precio: 419 €

A ver si alguien les puede echar un vistazo para decirme por dónde tiro, el encargado de la tienda me aconsejó especialmente el primero pero luego mirando por internet me he dado cuenta de que hay piezas bastante más potentes.

Podéis ver más portátiles de la misma tienda desde aqui: http://www.appinformatica.com/portatiles.htm

Una pregunta que siempre surje a la hora de comprar un PC: ¿para qué lo voy a usar?, como ya he comenatado es para la universidad (ingeniería informática), asi que en ello entra la programación, gráficos (por eso necesito una tarjeta gráfica que no se quede obsoleta a los 2 años) y alguna cosa más.

No tiene por qué ser uno de esos 2 PC´s, si tienen alguna sugerencia mejor de esa página me gustaría oírla, o piezas específicas que me recomendéis, sin embargo también me gustaría saber qué opináis sobre los dos que he mencionado; el problema es que yo no estoy muy metido en el tema del hardware.

Gracias por adelantado. Saludos.

[EDITO: El code está corregido, le faltan cosas como borrar números, limpiar el edit o cambiar de signo, pero lo que lleva por ahora funciona bien.]

Buenas, en mis avances con la API de windows he conseguido hacer una calculadora muy básica con interfaz, sin embargo no me imprime el resultado, asi que después de varios días dándole vueltas y de habérselo planteado a un par de conocidos que no han encontrado el fallo lo posteo aqui:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
#include <stdio.h>
#include <string.h>

//ID´s
enum {ID_LABEL, ID_EDIT, ID_BOTONIGUAL, ID_BOTONSUMAR, ID_BOTONRESTAR, ID_BOTONMULTIPLICAR, ID_BOTONDIVIDIR, ID_BOTONCOMA, ID_BOTONSIGNO, ID_BOTONCERO, ID_BOTON1, ID_BOTON2, ID_BOTON3, ID_BOTON4, ID_BOTON5, ID_BOTON6, ID_BOTON7, ID_BOTON8, ID_BOTON9};


//Prototipos
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

void imprimirEdit (int i);                                                  //Funcion que concatena los numeros al hacer clic en los botones
double calcular (double primer_num, double segundo_num, int operacion);     //Funcion que realiza las operaciones

HINSTANCE estancia;
HWND label;
HWND edit;
//Botones->Numeros
HWND boton1;
HWND boton2;
HWND boton3;
HWND boton4;
HWND boton5;
HWND boton6;
HWND boton7;
HWND boton8;
HWND boton9;
HWND boton0;
HWND botonComa;
HWND botonSigno;
//Botones->Operadores
HWND botonIgual;
HWND botonSumar;
HWND botonRestar;
HWND botonMultiplicar;
HWND botonDividir;



/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nCmdShow)
{
   HWND hwnd;               /* This is the handle for our window */
   MSG messages;            /* Here messages to the application are saved */
   WNDCLASSEX wincl;        /* Data structure for the windowclass */

   estancia = hThisInstance;

   /* The Window structure */
   wincl.hInstance = hThisInstance;
   wincl.lpszClassName = szClassName;
   wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
   wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
   wincl.cbSize = sizeof (WNDCLASSEX);

   /* Use default icon and mouse-pointer */
   wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
   wincl.lpszMenuName = NULL;                 /* No menu */
   wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
   wincl.cbWndExtra = 0;                      /* structure or the window instance */
   /* Use Windows's default colour as the background of the window */
   wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

   /* Register the window class, and if it fails quit the program */
   if (!RegisterClassEx (&wincl))
       return 0;

   /* The class is registered, let's create the program*/
   hwnd = CreateWindowEx (
          0,                   /* Extended possibilites for variation */
          szClassName,         /* Classname */
          "Calculadora",       /* Title Text */
          WS_OVERLAPPEDWINDOW, /* default window */
          CW_USEDEFAULT,       /* Windows decides the position */
          CW_USEDEFAULT,       /* where the window ends up on the screen */
          544,                 /* The programs width */
          375,                 /* and height in pixels */
          HWND_DESKTOP,        /* The window is a child-window to desktop */
          NULL,                /* No menu */
          hThisInstance,       /* Program Instance handler */
          NULL                 /* No Window Creation data */
          );

   /* Make the window visible on the screen */
   ShowWindow (hwnd, nCmdShow);

   /* Run the message loop. It will run until GetMessage() returns 0 */
   while (GetMessage (&messages, NULL, 0, 0))
   {
       /* Translate virtual-key messages into character messages */
       TranslateMessage(&messages);
       /* Send message to WindowProcedure */
       DispatchMessage(&messages);
   }

   /* The program return-value is 0 - The value that PostQuitMessage() gave */
   return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   //Variables
   char cadenaEditMain [35];
   static int operacion;
   static double primer_num, segundo_num, resultado;

   PAINTSTRUCT ps;
   HDC hdc;


   switch (message)
   {
       case WM_CREATE:
       {
           label = CreateWindow ("Static","Texto", WS_CHILD | WS_VISIBLE, 20, 20, 175, 25, hwnd, 0, estancia, 0);
           edit = CreateWindowEx (WS_EX_CLIENTEDGE, "edit", 0, ES_RIGHT | ES_NUMBER | WS_BORDER | WS_CHILD | WS_VISIBLE, 20, 50, 175, 25, hwnd, (HMENU)ID_EDIT, estancia, 0);

           boton1 = CreateWindow ("Button", "1", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 90, 40, 25, hwnd, (HMENU) ID_BOTON1, estancia, 0);
           boton2 = CreateWindow ("Button", "2", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 90, 40, 25, hwnd, (HMENU) ID_BOTON2, estancia, 0);
           boton3 = CreateWindow ("Button", "3", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 90, 40, 25, hwnd, (HMENU) ID_BOTON3, estancia, 0);
           boton4 = CreateWindow ("Button", "4", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 120, 40, 25, hwnd, (HMENU) ID_BOTON4, estancia, 0);
           boton5 = CreateWindow ("Button", "5", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 120, 40, 25, hwnd, (HMENU) ID_BOTON5, estancia, 0);
           boton6 = CreateWindow ("Button", "6", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 120, 40, 25, hwnd, (HMENU) ID_BOTON6, estancia, 0);
           boton7 = CreateWindow ("Button", "7", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 150, 40, 25, hwnd, (HMENU) ID_BOTON7, estancia, 0);
           boton8 = CreateWindow ("Button", "8", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 150, 40, 25, hwnd, (HMENU) ID_BOTON8, estancia, 0);
           boton9 = CreateWindow ("Button", "9", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 150, 40, 25, hwnd, (HMENU) ID_BOTON9, estancia, 0);
           boton0 = CreateWindow ("Button", "0", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 180, 40, 25, hwnd, (HMENU) ID_BOTONCERO, estancia, 0);
           botonComa = CreateWindow ("Button", ",", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 65, 180, 40, 25, hwnd, (HMENU) ID_BOTONCOMA, estancia, 0);
           botonSigno = CreateWindow ("Button", "+/-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 110, 180, 40, 25, hwnd, (HMENU) ID_BOTONSIGNO, estancia, 0);
           botonSumar = CreateWindow ("Button", "+", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 90, 40, 25, hwnd, (HMENU) ID_BOTONSUMAR, estancia, 0);
           botonRestar = CreateWindow ("Button", "-", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 120, 40, 25, hwnd, (HMENU) ID_BOTONRESTAR, estancia, 0);
           botonMultiplicar = CreateWindow ("Button", "*", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 150, 40, 25, hwnd, (HMENU) ID_BOTONMULTIPLICAR, estancia, 0);
           botonDividir = CreateWindow ("Button", "/", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 165, 180, 40, 25, hwnd, (HMENU) ID_BOTONDIVIDIR, estancia, 0);
           botonIgual = CreateWindow ("Button", "=", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 20, 220, 40, 25, hwnd, (HMENU) ID_BOTONIGUAL, estancia, 0);
       }

       case WM_PAINT:
       {
           hdc = BeginPaint(hwnd, &ps);
EndPaint(hwnd, &ps);
return 0;
       }

       case WM_COMMAND:
       {
           switch (wParam)
           {
               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
               {
                   imprimirEdit (1);
                   break;
               }
               case ID_BOTON2:
               {
                   imprimirEdit (2);
                   break;
               }
               case ID_BOTON3:
               {
                   imprimirEdit (3);
                   break;
               }
               case ID_BOTON4:
               {
                   imprimirEdit(4);
                   break;
               }
               case ID_BOTON5:
               {
                   imprimirEdit(5);
                   break;
               }
               case ID_BOTON6:
               {
                   imprimirEdit(6);
                   break;
               }
               case ID_BOTON7:
               {
                   imprimirEdit(7);
                   break;
               }
               case ID_BOTON8:
               {
                   imprimirEdit(8);
                   break;
               }
               case ID_BOTON9:
               {
                   imprimirEdit(9);
                   break;
               }
               case ID_BOTONCERO:
               {
                   imprimirEdit(0);
                   break;
               }
               case ID_BOTONCOMA:
               {
                   break;
               }
               case ID_BOTONSUMAR:
               {
                   operacion = 1;                                    //Cambia el valor de "operacion" para indicar que se va a sumar
                   GetWindowText (edit, cadenaEditMain, 34);         //Obtiene el numero ingresado en el edit
                   primer_num = atof (cadenaEditMain);               //Transforma la cadena obtenida en un double y lo guarda en "primer_num"
                   SetWindowText (edit, "");                         //Limpia el edit
                   break;
               }
               case ID_BOTONRESTAR:
               {
                   operacion = 2;                                    //Cambia el valor de "operacion" para indicar que se va a restar
                   GetWindowText (edit, cadenaEditMain, 34);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONMULTIPLICAR:
               {
                   operacion = 3;                                    //Cambia el valor de "operacion" para indicar que se va a multiplicar
                   GetWindowText (edit, cadenaEditMain, 34);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONDIVIDIR:
               {
                   operacion = 4;                                    //Cambia el valor de "operacion" para indicar que se va a dividir
                   GetWindowText (edit, cadenaEditMain, 34);
                   primer_num = atof (cadenaEditMain);
                   SetWindowText (edit, "");
                   break;
               }
               case ID_BOTONIGUAL:
               {
                   GetWindowText (edit, cadenaEditMain, 34);         //Obtiene el numero ingresado en el edit
                   segundo_num = atof (cadenaEditMain);              //Transforma la cadena obtenida en un double y lo guarda en "segundo_num"
                   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"
                   sprintf (cadenaEditMain, "%f", resultado);        //Se transforma el double obtenido en una cadena y se guarda en "cadenaEditMain"
                   SetWindowText (edit, cadenaEditMain);             //Se imprime en el edit la cadena donde se encuentra el resultado
                   break;
               }

               break;
           }
           break;
       }

       case WM_DESTROY:
           PostQuitMessage (0);
           break;
       default:
           return DefWindowProc (hwnd, message, wParam, lParam);
   }

   return 0;
}

void imprimirEdit (int i)                        //Funcion que concatena los numeros al hacer clic en los botones
{
   char cadenaEdit [35];                        //Variable donde se guardara lo que hay en el edit (no es la misma variable que cadenaEditMain)
   char numero [2];                             //Variable donde se guardara el numero de la tecla presionada
   sprintf (numero, "%i", i);                   //Se transforma el numero (i) del tipo entero a una cadena

   GetWindowText (edit, cadenaEdit, 34);        //Se obtiene lo que hay en el edit y se guarda en "CadenaEdit"
   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"
   SetWindowText (edit, cadenaEdit);            //Se imprime el nuevo numero en el edit
}

double calcular (double primer_num, double segundo_num, int operacion)   //Funcion que realiza las operaciones
{
   double resultado;                                                    //Variable donde se guardara el resultado (sera lo que se retorne)

   switch (operacion)                                                   //Ver lo que hay en la variable "operacion"
   {
       case 1:                                                          //En caso de que sea "1" se suma el primer numero al segundo
       {
           resultado = primer_num + segundo_num;
           break;
       }
       case 2:                                                          //En caso de que sea "2" se resta el primer numero al segundo
       {
           resultado = primer_num - segundo_num;
           break;
       }
       case 3:                                                          //En caso de que sea "3" se multiplica el primer numero por el segundo
       {
           resultado = primer_num * segundo_num;
           break;
       }
       case 4:                                                          //En caso de que sea "4" se divide el primer numero entre el segundo
       {
           resultado = primer_num / segundo_num;
           break;
       }
       default:                                                         //Si no se realiza ninguna operacion se imprime en el edit un mensaje, con esto sabriamos si ha habido algun error
       {
           SetWindowText (edit, "No se ha realizado ninguna operacion.");
           break;
       }
   }

   return resultado;                                                    //Devuelve el resultado
}


El fallo está en que al darle al signo igual, en vez de imprimir el resultado, manda el segundo número introducido. Todas las funciones y procesos van comentados.

Gracias por adelantado, saludos.

EDITO: El code está corregido, le faltan cosas como borrar números, limpiar el edit o cambiar de signo, pero lo que lleva por ahora funciona bien.

Buenas:

A ver si me podéis ayudar en un pequeño problemilla, y es que he intentado abrir los puertos de 2 routers diferentes, uno ZyXEL ( he seguido esta guía: http://www.adslzone.net/tutorial-20.2.html ) y otro Netgear. La cosa es que después de seguir todo el procedimiento y de darle a "Save" y a "Apply" el puerto sigue cerrado.

Si alguien sabe cuál puede ser la razón de esto le agradecería que me lo comentara. Saludos.

[HINSTANCE mi_instance;]

Buenas:

Siguiendo el consejo de тαптяαпсє me he puesto a explorar Win API y he conseguido crear menus/sub-menus, botones y edit aparte de utilizar algunas funciones para toquetear archivos y leer datos básicos del disco duro (me pudo la curiosidad y pasé de la interfaz a otras cosas  ).

Bien, he podido crear eventos a los menus/sub-menus como se puede ver en este ejemplo:

Código (cpp) [Seleccionar] Expandir

case WM_COMMAND:
           switch(LOWORD(wParam))
           {
               case item1_menu2:
                   MessageBox(hwnd, "Mensaje de prueba", "Titulo del mensaje", MB_OK);
                   break;
               case item2_menu2:
                   PostQuitMessage(0);
                   break;
           }
           break;

Como sigo algunas guías en inglés por falta de material en castellano no comprendí muy bien lo que hace switch(LOWORD(wParam)) pero puedo suponer razonando que es algo asi como "al darle clic a ...", corregídme si me equivoco.

Ahora, he intentado crear un evento a un botón y un edit pero no lo consigo; aqui os dejo el código (en rojo lo correspondiente al botón, lo demás es lo que te da como plantilla Code::Blocks):

#include <windows.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

HINSTANCE mi_instance;

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nCmdShow)
{
   HWND hwnd;               /* This is the handle for our window */
   MSG messages;            /* Here messages to the application are saved */
   WNDCLASSEX wincl;        /* Data structure for the windowclass */
   mi_instance = hThisInstance;

   /* The Window structure */
   wincl.hInstance = hThisInstance;
   wincl.lpszClassName = szClassName;
   wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
   wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
   wincl.cbSize = sizeof (WNDCLASSEX);

   /* Use default icon and mouse-pointer */
   wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
   wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
   wincl.lpszMenuName = NULL;                 /* No menu */
   wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
   wincl.cbWndExtra = 0;                      /* structure or the window instance */
   /* Use Windows's default colour as the background of the window */
   wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

   /* Register the window class, and if it fails quit the program */
   if (!RegisterClassEx (&wincl))
       return 0;

   /* The class is registered, let's create the program*/
   hwnd = CreateWindowEx (
          0,                   /* Extended possibilites for variation */
          szClassName,         /* Classname */
          "Code::Blocks Template Windows App",       /* Title Text */
          WS_OVERLAPPEDWINDOW, /* default window */
          CW_USEDEFAULT,       /* Windows decides the position */
          CW_USEDEFAULT,       /* where the window ends up on the screen */
          544,                 /* The programs width */
          375,                 /* and height in pixels */
          HWND_DESKTOP,        /* The window is a child-window to desktop */
          NULL,                /* No menu */
          hThisInstance,       /* Program Instance handler */
          NULL                 /* No Window Creation data */
          );

   /* Make the window visible on the screen */
   ShowWindow (hwnd, nCmdShow);

   /* Run the message loop. It will run until GetMessage() returns 0 */
   while (GetMessage (&messages, NULL, 0, 0))
   {
       /* Translate virtual-key messages into character messages */
       TranslateMessage(&messages);
       /* Send message to WindowProcedure */
       DispatchMessage(&messages);
   }

   /* The program return-value is 0 - The value that PostQuitMessage() gave */
   return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)                  /* handle the messages */
   {
       case WM_CREATE:
       {
           HWND hwnd_boton1 = CreateWindowEx (NULL, "BUTTON", "Texto", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 100, 100, 90, 25, hwnd, NULL, mi_instance, NULL);
           break;
       }

       case WM_DESTROY:
           PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
           break;
       default:                      /* for messages that we don't deal with */
           return DefWindowProc (hwnd, message, wParam, lParam);
   }

   return 0;
}

Para crear el evento he añadido debajo del WM_CREATE esto otro basándome en los ejemplos de los tutoriales (en rojo señalo dónde me da error):

case WM_COMMAND:
       {
           if ((HWND)lParam==hwnd_boton1)
           {
               MessageBox(NULL, "Se ha presionado el boton", "Título", MB_OK | MB_ICONEXCLAMATION);
           }
           break;
       }

De ahi me surge otra duda: ¿Por qué para crear eventos en los menus se usa (LOWORD(wParam)) y en botones ((HWND)lParam==hwnd_boton1) si en ambos casos se hace "clic" para activar el evento?.

Gracias por adelantado. Saludos.

Buenas:

Después de un tiempo explorando la programación en C++ he acabado varios libros/tutoriales, sin embargo ahora mismo estoy atascado.

En principio os comento que me he visto por completo los video-tutoriales de Jesus Conde (os lo dejo para que veais el temario): http://foro.elhacker.net/programacion_cc/video_tutorial_programacion_c-t249577.0.html

Luego estuve revisando "C con clase" para practicar, resolver dudas y completar cosas que no venían en los video-tutoriales: http://c.conclase.net/curso/index.php

Asi que después de 2 dias buscando por internet guías y libros para seguir avanzando no he encontrado nada nuevo. De primeras destaco que no he dado nada relacionado con internet, es decir, programar aplicaciones que conectan a la red. Tampoco he visto mucho sobre archivos (solo un poco por encima: crear archivos, guardarlos, cargarlos y poco más). Y no tengo idea alguna de cómo salir de la tabla de comandos y crear una interfaz para un programa; ya me comentaron que en C++ esto era a base de códigos pero he revisado bastantes páginas y solo mencionan muy por encima algunas cosas sobre la librería "windows.h" sin explicar comandos ni códigos (tampoco estoy muy seguro de que sea la librería estándar para crear interfaces). Otra cosa es, ¿de qué forma se puede "comunicar" el programa con el sistema operativo?, es decir, forzarlo a hacer acciones (apagar, acceder a un disco duro, comprobar datos del SO, leer dispositivos y un largo etcétera).

Vamos, que las funciones, clases, objetos, punteros, referencias, herencias y el resto de cosas que he aprendido solo me sirven para hacer calculadoras  .

Espero que me aconsejéis por dónde continuar y alguna guía que seguir. Gracias por adelantado, saludos.

Buenas:

Después de varios días siguiendo los video-tutoriales de Jesus Conde y apoyándome en algunos libros que encontré, he llegado al final de las clases y objetos (o al menos por ahora se pasa a otro tema). Asi pues aqui comento las dudas que me han quedado:

1- En algunas guías añaden el siguiente código después de llamar a las librerías:

Código [Seleccionar] Expandir

using namespace std;

Mientras que en otras pone lo siguiente dentro de main:

Código [Seleccionar] Expandir

using std::cout;
using std::cin;
usgin std::endl;

¿Para qué es este código?, podría suponer que es para que funcione "cout, cin y endl", sin embargo eso va dentro de la librería "iostream", ¿entonces qué hace este código exactamente?.

2- En este ejemplo:

Código [Seleccionar] Expandir

#include <iostream>
int myFunc(unsigned short int x);
int main()
{
   unsigned short int x, y;
   x = 7;
   y = myFunc(x);
   std::cout << "x: " << x << " y: " << y << "\n";
   return 0;
}

int myFunc(unsigned short int x)
{
   return (4*x);
}

Es obligatorio mandarle un valor a "unsigned short int x" desde:

y = myFunc(x);

Sé que este valor se puede modificar dentro de la función, ¿pero no hay ninguna forma de dejarlo vacio, es decir, no inicializarlo?.

3- He dado la herramienta "inline", sin embargo, ¿cuántas líneas como máximo puede tener una función para que el usar inline sea efectivo?, ya que según he leído llegado a un punto degrada el programa.

4- ¿El siguiente prototipo de función es considerado como inline por el compilador (como en el caso de las clases) o hay que añadirle la palabra "inline"?, mi duda surje debido a que se define la función en el prototipo:

#include <iostream>
using namespace std;

int funcion1 (int numero) { return numero * 5; }

int main ()

{
int x;
x = funcion1 (5);
cout << "Prueba.";

return 0;
}

5- Entre los ejercicios de un libro escrito por Pello Xabier Altadill Izura encontré este:

Código [Seleccionar] Expandir

#include <iostream>
using namespace std;

int main ()
{
// Sacamos el tamaño de cada tipo
cout << "El tamaño del int es:\t\t" << sizeof(int) << " bytes.\n";
cout << "El tamaño del short es:\t" << sizeof(short int) << " bytes.\n";
cout << "El tamaño del long es:\t" << sizeof(long int) << " bytes.\n";
cout << "El tamaño del char es:\t\t" << sizeof(char) << " bytes.\n";
cout << "El tamaño del float es:\t\t" << sizeof(float) << " bytes.\n";
cout << "El tamaño del double es:\t" << sizeof(double) << " bytes.\n";
// Sacamos por salida standar un mensaje
cout << "Termino el programa\n";
return 0;
}


Me ha extrañado un poco el ver que el tamaño de "int," el de "long int" y el de "float" es de 4 bytes, si ocupan lo mismo ¿por qué uno puede almacenar números más altos que otro?.

6- Cuando creamos una clase declaramos algunas variables y funciones miembro como públicas y otras como privadas. Luego están las funciones "accessor", que sirven para poder acceder a un miembro privado atraves de uno público, hasta ahi lo entiendo. ¿Pero qué necesidad hay de declarar una variable o función como privada y luego manejarla através de una función accessor?, ¿qué problema puede haber con declararlo todo público (o al menos lo que sabes que vas a usar fuera de la clase)?.

|----------------------------------------------------------------------------------------------------------------------------|

Creo que eso es todo, aunque hay demasiadas preguntas... las he ido acumulando para hacer un pack de dudas y no crear 9392 temas

Saludos!

Buenas, escribo para plantear una pregunta de principiante:

Bien, hace unos años estuve programando en C++ siguiendo un libro llamado "Aprenda C++ como si estuviera en primero"; en dicho libro aprendí que para mostrar un mensaje en la pantalla se usa:

Código [Seleccionar] Expandir

printf

Sin embargo ahora, buscando varias versiones de este manual para volver a la programación, acabé cansándome ya que todas las que encontré tenían un lenguaje un poco complejo, y no conseguí dar con la versión para "super principiantes nivel 0" que era con la que me entendía.

Al final opté por buscar otros manuales y acabé con un pequeño video-tutorial de 9 capítulos que te intruce en la programación (aqui os dejo el primer capitulo: http://www.youtube.com/watch?v=eVaFqHE1mIY ). Mi duda surje al fijarme en que en vez de usar "printf" para imprimir un mensaje en la pantalla, usa el código "cout".

De la misma forma después de un comando añade "<<" en el caso de cout y ">>" en el caso de cin. Quisiera saber a qué es debido que use comandos en C++ que no eran los que aprendí hace unos años ni son los mismos que usan los programadores que hay en esta página (he revisado varios scripts y parece otro lenguaje O.o).


Disculpad si es una pregunta demasiado tonta, pero me resulta demasiado extraño que estudiando el mismo lenguaje use códigos diferentes.

Saludos.

Buenas foreros:

Después de bastante tiempo fuera de este mundillo creo este tema para que me refresquéis un poco la memoria. En primer lugar decir que ahora estoy muy metido en el photoshop (si me va bien en este foro crearé un pequeño post para hacer firmas/avatares a los que quieran); sin embargo hace cosa de 3 años estaba metido en programación C++ (nivel básico) pero por los estudios tuve que dejarlo de lado. Ahora hace unos meses, por un par de proyectos que tuve con un colega, me metí mucho en programación web (HTML y CSS) pero también nivel básico, comprendía las estructuras y las funciones aunque cuando los códigos eran muy complejos tomaba como base uno ya hecho y lo modificaba a mi gusto. Toda esta rallada la explico para que tengáis en cuenta que nunca le he dedicado a la programación mucho tiempo ni he llegado a profundizar en el tema, sin embargo siempre me ha apasionado la informática en general.

Y llegados a este punto os planteo mis dudas:

Después de tanto tiempo, ¿qué idioma de programación me aconsejáis?, aun teníendo en cuenta mis conocimientos de nivel 0 no busco uno por su sencillez sino por su capacidad, las cosas que se puedan hacer con él. Tenía entendido que con Visual Basic se pueden hacer todo tipo de programas y abarcar el tema del hacking por completo, pero me lia el hecho de que existan distintas variaciones (Visual Basic 6.0, Visual Basic Net y creo que alguna más). Aun asi me gustaría saber qué idioma me aconsejáis aprender con el que cual poder programar sin limitaciones y trabajar el tema del hacking (tanto en PC como webs).

Otra de mis dudas es: cuando estuve con el C++ no llegué a trabajar la parte gráfica de los programas asi que no tengo ni idea de como va (todo lo que hacia tenía una pantalla negra con letras blancas y había que manejarlo con el teclado xD), ¿hay que usar algún compilador específico para poder darle un diseño al programa?, ¿o hay que programarlo también?, según he visto con Visual Basic esto no es asi, el propio compilador te da la opción de añadir las imágenes, modificar el tamaño del programa, los botones y las casillas, etc.

Bueno, espero aclararme esas dos ideas, gracias por adelantado, saludos.