Mensajes

Ubuntu es el sistema operativo ideal, y por ello es el que se estudia en las universidades, Windows más que nada se ve un poco por encima porque tuvo una buena entrada al mercado y consiguió que se usara tanto.

Se ve que muy experta no es esa gente que mencionas si dicen eso jeje. Windows 7 y ubuntu NO SE PARECEN EN NADA, no digo que uno sea mejor que otro sino que no tienen nada que ver y por tanto no deberian compararse dado que repito NO SE PARECEN EN NADA, asi que copias descaradas nada de nada.
Por otro lado decir que xp es mejor que el windows 7 y hacerlo asi reconociendo encima que ni siquiera se a probado el windows 7 es cuanto menos ridiculo. Sin duda el windows 7 le da tropecientas vueltas al xp que no es mas que un OBSOLETO sistema operativo de 10 años de antiguedad que no se puede para nada poner a la altura del windows 7 en ningun aspecto.

¿Que Windows XP/7 es qué...?... macho, la primera actualización de Windows XP pesaba tanto como el propio sistema operativo y Windows 7 no se quedó muy lejos; Windows no es un sistema operativo repleto de fallos y chapuzas informáticas, Windows en si es un bug.

WINDOWS 2000 = WINDOWS XP = WINDOWS 7, leed un poco de estructura de sistemas operativos, es exactamente lo mismo, acarrea los mismos fallos, el mismo consumo inmenso de recursos, la base algorítmica es idéntica.

¿QUE WINDOWS 7 VA MÁS RÁPIDO QUE WINDOWS XP?, LOL!, ¿NO TENDRÁ ALGO QUE VER QUE WINDOWS 7 NECESITE 1GB MÍNIMO PARA ARRANCAR Y QUE SI QUIERES QUE TARDE MENOS DE 10 MINUTOS EN ABRIR UNA CARPETA NECESITAS 3-4GB?.

Y por último, WINDOWS NO ES UNA COPIA DE UBUNTU, no se parecen en nada, como he dicho antes Linux y en particular la distribución Ubuntu es el sistema operativo ideal por su estructura y los algoritmos que lo componen.

MIS OJOS!, LO QUE LEO:

UBUNTU ES MIL VECES MEJOR! eso no se preunta, windows sirve para los usuarios que no saben mucho de computación, ahora el linux sirve para la gente como nosotros, interesados en la informática, ahora.. no se comparan solo así por así, no le puedes bajar el nivel tanto a ubuntu! xD saludos
Eso seguramente lo dice alguien que tiene instalado Windows y lo usa regularmente. Incluso mas que el SO del que habla... Tio, pero ni siquiera das fundamentos.

Citar
Ubuntu y todas las distros Linux son - más seguras, rápidas.
Lo de que sean mas rápidas es tan falso como que los cerdos pueden volar. Todo depende de las especificaciones del PC. Y dirás, pues usa otro entrono.. y yo diré.. pues usare Xp en vez de 7.. Pues acaba siendo lo mismo...

Lo de la seguridad Falso también. Si, puede que sean mas seguras por su manera de llevar los permisos y el control de usuarios. Pero, cualquier SO seria 100% seguro, si no hubiese un usuario.

En primer lugar, ningun informático que se deje preciar usa Windows. Como ha apuntado el compañero Windows solo lo usan usuarios que no tienen mucha idea de computación porque sabiendo los fallos que tiene y cómo está programado seguro que excepto Bill Gates pocos más lo usuarían... No hace falta estudiar una carrera para saber esto, basta con leer un poco.

En segundo lugar, Windows es una carpeta "C/" y ala todo dentro, Ubuntu es un SO con una estructura definida donde los niveles inferiores no pueden acceder a niveles superiores y por tanto es muchísimo más seguro. ¿No dice nada el hecho de que el 90% de los servidores sean Linux?, yo creo que el 10% restante es de servidores de Microsoft y compañías relacionadas con ella.

Y en tercer lugar, Ubuntu corre sin problemas en PC's que considerabas chatarra, Windows pide en todas sus versiones un PC exagerado; y aqui falta comentar que los PC's se fabrican pensando principalmente en Windows puesto que es el sistema operativo que más se usa, imaginaos que se fabricaran inclinados a Linux...

Tendría que subir las transparencias de la facultad donde puedes ver la comparación entre Windows y Ubuntu, pero tengo que preguntar si se pueden subir a foros.

Aqui nadie ha hablado de Apple, y es un caso especial puesto que no se identifica solo por SO sino también por el hardware fabricado de forma específica para él; esto le da muchos parámetros que no tienen otros PC's.

Ya en serio, si quieres un buen PC, Windows es la peor opción a la que puedes tirar, que no te engañe el hecho de que sea el SO más usado porque sea el más antiguo...

UBUNTU ES MIL VECES MEJOR! eso no se preunta, windows sirve para los usuarios que no saben mucho de computación, ahora el linux sirve para la gente como nosotros, interesados en la informática, ahora.. no se comparan solo así por así, no le puedes bajar el nivel tanto a ubuntu! xD saludos

Chapó, a ver si os informáis un poco como él acerca de sistemas operativos más allá de la páginas de Microsoft antes de decir tantas barbaridades.

[Saludos.]

Buenas:

Te puedo indicar cómo se gestionan de forma básica los procesos en Linux desde la terminal (en particular para Ubuntu):

top: muestra los procesos en ejecución y permite cerrarlos
ps: muestra la lista de procesos del usuario
kill ID: cierra un proceso
fg ID: sitúa en primer plano un proceso (que esté pausado o en segundo plano)
bg ID: pasa a segundo plano un proceso
&: se pone al final de un comando y sirve para ejecutarlo en segundo plano

Nota: Donde pone "ID" hay que sustituirlo por el número-ID del proceso

Lógicamente hay muchos más comandos, te basta con buscar un poco por internet.

Saludos.

La velocidad depende de la aceleración y del rozamiento, el rozamiento depende de la masa...

Todos los objetos son atraidos por la tierra a 9'8 m/s^2, lo cual quiere decir que por cada segundo el objeto aumentará su velocidad 9'8, esto es la situación ideal (sin ningún tipo de rozamiento).

Ahora, en el caso real, la aceleración se ve afectada por el rozamiento (fuerza que se opone al movimiento por el contacto entre dos superficies), por ejemplo, si empujamos una caja en una superficie de arena nos costará más que empujarla sobre una pista de hielo, el rozamiento del hielo es muy pequeño (que no es lo mismo que nulo) mientras que la arena ofrece mayor rozamiento.

En el caso de la pluma y la piedra, la pluma tarda más en caer no porque tenga mayor aceleración (todos los objetos sienten la misma atracción por la Tierra) sino porque el propio aire choca contra ella reduciendo la velocidad, y por tanto aunque acelere, la velocidad que ha ganado por segundo (9'8) gracias a la aceleración, la pierde por el choque con el aire.

PD: Sobre el vídeo solo es otra estrategema más para vender.

[Saludos.]

No comprendo muy bien qué preguntas, ¿quieres guardar en la matriz los datos según se vayan introduciendo?, en ese caso debes usar dos bucles anidados como has puesto en tu código:

Código (cpp) [Seleccionar] Expandir

for(i=0;i<n;i++)
     {  for(j=0;j<m;j++)
        {
         printf("ingrese numero de lesionados para la interseccion entre [Avenida %d,Calle %d]: ",i,j);

         scanf("%d",&cruce [j].(*R).lesionados);

printf("ingrese cantidad de vehiculos involucrados en la interseccion[Avenida %d,Calle %d]: ",i,j);

         scanf("%d",&cruce [j].(*R).vehiculos);

printf("ingrese fecha del accidente en la interseccion [Avenida %d,Calle %d]: ",i,j);

         scanf("%d",&cruce [j].(*R).fecha);
        }
        }

Pero esto no es correcto:

Código [Seleccionar] Expandir

&cruce [j].(*R).lesionados

En primer lugar "cruce" es una tabla bidimensional, no puedes dejar uno de los parámetros vacíos asi que debes poner también el número de filas (i):

Código (cpp) [Seleccionar] Expandir

&cruce[i][j].DATO

No entiendo muy bien qué ese "(*R)", pero no es necesario... a la tabla debes acceder con estos códigos:

Código (cpp) [Seleccionar] Expandir

cruce[i][j].lesionados
cruce[i][j].vehiculos
cruce[i][j].fecha

Lo cual tampoco te va a funcionar si no defines la tabla como tipo "accidente", es decir, asi:

Código (cpp) [Seleccionar] Expandir

void Llenar(accidente cruce[10][20],int n, int m,int accidentes) //En la función

int main()   //En el main
{

   accidente cruce[10][20];
.
.
.
}

Otra cosa es que usas variables que no has declarado, como por ejemplo la tabla "a" no está declarada en el main ni la variable "accidentes" (la primera se la pasas a la función "Mostrar" y la segunda a la función "Llenar").

Y por último en los codicionales haces lo siguiente:

Código (cpp) [Seleccionar] Expandir

If
{
//Instrucciones
}
{
else
//Instrucciones
}

El else no va dentro de las llaves, la estructura es siempre:

Código (cpp) [Seleccionar] Expandir

Instrucción principal
{
Instrucciones que la componen.
}

Con esto el programa funciona correctamente. Te he anotado los fallos pero los has cometido en varios lados del algoritmo, asi que revísalo entero.

Saludos.

[tabla=]

Buenas:

Te comento los errores:

Código (cpp) [Seleccionar] Expandir

#include define N=10

Eso no está bien escrito, el "define" se usa sin "include":

Código (cpp) [Seleccionar] Expandir

#define N=10

El cuerpo del programa se compone de:

Código (cpp) [Seleccionar] Expandir

int main()
{
}

En tu algoritmo no has puesto las llaves.

En el bucle has puesto:

tabla=tabla[i-1] + tabla[i-2];

Siempre hay que declarar la posición en la tabla a la que haces referencia, deberías poner:

Código (cpp) [Seleccionar] Expandir

tabla[i]=tabla[i-1] + tabla[i-2];

Creo que el "end" final lo has puesto para finalizar el bucle tipo Pascal ¿no? lol; en C/C++ cuando el bucle tiene más de una instrucción se usa llaves para señalar el inicio y fin:

Código (cpp) [Seleccionar] Expandir

for (i=2; i<=10; i++)
{       //Inicio
        //Instrucciones que componen el bucle
}     //Fin

Y por último los "%d" van entre comillas. Aqui te dejo el algoritmo corregido:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#define N=10

int main ()
{
int tabla[10];
int i;
int aux;

printf("%d", 0);
scanf("%d",&tabla[0]);
printf("%d\n", 1);
scanf("%d",&tabla[1]);

for (i=2;i<=10;i++)
{
tabla[i]=tabla[i-1] + tabla[i-2];
scanf("%d",tabla);
}
}

Saludos.

¿Y si pruebas asi?:

Código [Seleccionar] Expandir

#include <iostream>
using namespace std;

int main()
{
cout << "Hello World!\n";
return 0;
}

Es lo mismo pero quizá asi no te dé error.

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/

Es deprimente saber como está el mundo.

[Saludos.]

Buen aporte, seguro que le servirá a más de uno, pero te aconsejo para la próxima vez que uses la etiqueta "code".

Saludos.

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