Tutorial: creación de una aplicación de escritorio de Windows tradicional (C++)

En este tutorial se muestra cómo crear una aplicación de escritorio de Windows tradicional en Visual Studio. La aplicación que crea usa la API de Windows para mostrar "Hello, Windows desktop!" en una ventana. Puede utilizar el código que va a desarrollar en este tutorial como modelo para crear aplicaciones de escritorio de Windows.

La API de Windows (también conocida como API Win32, Desktop API de Windows y Classic API de Windows) es un marco basado en el lenguaje C para crear aplicaciones de Windows. Se ha usado para crear aplicaciones Windows durante décadas. Los marcos de trabajo más avanzados y fáciles de programar se han creado sobre la API de Windows. Por ejemplo, MFC, ATL y .NET. Incluso el código de Windows Runtime más moderno de las aplicaciones para UWP y Store escritas en C++/WinRT usa la API de Windows de forma subyacente. Para más información sobre la API de Windows, consulte Índice de la API de Windows.

Importante

La sección Creación del código al final de este documento muestra el código completo. Este tutorial cubre los distintos fragmentos de código de una aplicación Windows, pero no codificará a medida que avanza, ya que se omiten algunos detalles en los fragmentos de código para centrarse en las partes más importantes. Puede copiar el código completo y pegarlo en el proyecto al final.

Requisitos previos

• Un equipo que ejecuta Microsoft Windows 7 o versiones posteriores. Recomendamos Windows 11 o una versión posterior para obtener la mejor experiencia de desarrollo.

• Una copia de Visual Studio. Para obtener información sobre cómo descargar e instalar Visual Studio, consulte Instalación de Visual Studio. Al ejecutar el programa de instalación, asegúrese de que la carga de trabaja Desarrollo para el escritorio con C++ está activada. No se preocupe si no ha instalado esta carga de trabajo al instalar Visual Studio. Puede ejecutar de nuevo el programa de instalación e instalarla ahora.

  

• Conocimientos básicos sobre el uso del IDE de Visual Studio. Si ha usado antes las aplicaciones de escritorio de Windows, probablemente esté al día. Para ver una introducción, consulte Paseo por las características del IDE de Visual Studio.

• Conocer todos los fundamentos del lenguaje C++ para poder continuar. No se preocupe, no hacemos nada que sea muy complicado.

Creación de un proyecto de escritorio de Windows

Siga estos pasos para crear su primer proyecto de escritorio de Windows. Según la nota al principio de este tutorial, el código completo está disponible en la sección Construir el código al final del tutorial. Siga los pasos para crear el proyecto, pero no pegue las siguientes secciones de código hasta el final, cuando se presente el código completo de la aplicación. Algunos detalles se omiten en los fragmentos de código para centrarse en las partes más importantes. Puede copiar el código completo y pegarlo en el proyecto al final.

Para simplificar la explicación. Para ver la documentación de su versión preferida de Visual Studio, use el control de selector Versión. Se encuentra en la parte superior de la tabla de contenido de esta página.

Para crear un proyecto de escritorio de Windows en Visual Studio, siga estos pasos:

1. En el menú principal, seleccione Archivo>Nuevo>Proyecto para abrir el cuadro de diálogo Crear nuevo proyecto.

2. En la parte superior del cuadro de diálogo, establezca Lenguaje en C++, establezca Plataforma en Windows y establezca Tipo de proyecto en Escritorio.

3. En la lista filtrada de tipos de proyecto, seleccione Asistente para escritorio de Windows y, después, Siguiente. En la página siguiente, escriba un nombre para el proyecto, por ejemplo, DesktopApp.

4. Elija el botón Crear para crear el proyecto.

5. Se muestra el cuadro de diálogo Proyecto de escritorio de Windows. En la lista desplegable Tipo de aplicación, asegúrese de seleccionar Aplicación de escritorio (.exe). Dado que estamos creando una aplicación Windows, si elegimos la aplicación de consola obtendremos un proyecto que no se compilará dado el código que vamos a utilizar. A continuación, en Opciones adicionales, seleccione Proyecto vacío. Elija Aceptar para crear el proyecto.

6. En el Explorador de soluciones, haga clic con el botón derecho en el proyecto DesktopApp, elija Agregar y, luego, seleccione Nuevo elemento.

   

   La animación muestra cómo se hace clic con el botón derecho en el nombre del proyecto en el Explorador de soluciones, se selecciona Agregar en el menú que aparece y, a continuación, se elige la opción Nuevo elemento.

7. En el cuadro de diálogo Agregar nuevo elemento , seleccione Archivo C++ (.cpp). En el cuadro Nombre, escriba un nombre para el archivo, por ejemplo, HelloWindowsDesktop.cpp. Haga clic en Agregar.

   

El proyecto se crea y el archivo de código fuente se abre en el editor.

El código.

A continuación, aprenda a crear el código de una aplicación de escritorio de Windows en Visual Studio.

Donde el código comienza a ejecutarse en una aplicación de escritorio de Windows

1. Al igual que todas las aplicaciones de C y C++ deben tener una función main como punto de partida, todas las aplicaciones de escritorio de Windows deben tener una función WinMain. WinMain tiene la siguiente sintaxis.

   int WINAPI WinMain(
      _In_ HINSTANCE hInstance,
      _In_opt_ HINSTANCE hPrevInstance,
      _In_ LPSTR     lpCmdLine,
      _In_ int       nCmdShow
   );
   

   Para información sobre los parámetros y el valor devuelto de esta función, consulte Punto de entrada de WinMain.

   Nota:

   ¿Qué son todas esas palabras adicionales, como WINAPI, CALLBACK, HINSTANCE o _In_? La API de Windows hace un uso extensivo de tipos de definiciones y macros de preprocesador para abstraer algunos de los detalles de tipos y código específico de la plataforma, como las convenciones de llamada, las declaraciones __declspec y las pragmas del compilador. En Visual Studio, puede usar la característica Información rápida de IntelliSense para ver qué definen estas definiciones de tipos y macros. Mantenga el mouse sobre la palabra de interés o selecciónela y presione Ctrl+K, Ctrl+I para una ventana emergente pequeña que contenga la definición. Para más información, vea Usar IntelliSense. Los parámetros y los tipos de valor devuelto suelen usar anotaciones SAL para ayudarle a detectar errores de programación. Para más información, consulte Uso de anotaciones SAL para reducir los defectos en el código de C/C++.

2. Los programas de escritorio de Windows requieren <windows.h>. También verá con frecuencia #include <tchar.h>. Esto es para facilitar la escritura de una aplicación que pueda funcionar con char o wchar_t. La forma en que funciona es que en su lugar se usa la macro TCHAR en el código, que se resuelve en última instancia para wchar_t si el símbolo UNICODE está definido en el proyecto, de lo contrario, se resuelve para char. Si siempre compila con UNICODE habilitado, no necesita TCHAR y solo puede usar wchar_t directamente. Para obtener más información, vea Uso de asignaciones de texto genérico. El código siguiente muestra estas dos instrucciones #include en la parte superior del archivo.

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

3. Además de la función WinMain, todas las aplicaciones de escritorio de Windows deben tener una función de procedimiento de ventana. Esta función se denomina WndProc, pero puede asignarle el nombre que quiera en el código. WndProc tiene la siguiente sintaxis.

   LRESULT CALLBACK WndProc(
      _In_ HWND   hWnd,
      _In_ UINT   message,
      _In_ WPARAM wParam,
      _In_ LPARAM lParam
   );
   

   En esta función, escribirá código para controlar los mensajes que la aplicación recibe de Windows cuando se producen eventos. Por ejemplo, si un usuario elige un botón Aceptar en la aplicación, Windows le envía un mensaje. Escribir código dentro de una función WndProc que haga lo que sea adecuado. Esto se conoce como controlar un evento. Solo se controlan los eventos que son pertinentes para la aplicación.

   Para más información, vea Procedimientos de ventanas.

Agregar funcionalidad a la función WinMain

1. En la función WinMain, debe capturar información básica sobre la ventana principal. Para ello, rellene una estructura de tipo WNDCLASSEX. Esta estructura contiene información sobre la ventana, por ejemplo, el icono de la aplicación, el color de fondo de la ventana, el nombre para mostrar en la barra de título, etc. Es importante destacar que contiene un puntero de función al procedimiento de la ventana que controla los mensajes que Windows envía a la aplicación. El ejemplo siguiente muestra una estructura típica de WNDCLASSEX:

   WNDCLASSEX wcex;
   
   wcex.cbSize         = sizeof(WNDCLASSEX);
   wcex.style          = CS_HREDRAW | CS_VREDRAW;
   wcex.lpfnWndProc    = WndProc;
   wcex.cbClsExtra     = 0;
   wcex.cbWndExtra     = 0;
   wcex.hInstance      = hInstance;
   wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
   wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
   wcex.lpszMenuName   = NULL;
   wcex.lpszClassName  = szWindowClass;
   wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   

   Para información sobre los campos de esta estructura, consulte WNDCLASSEX.

2. Una vez que haya rellenado la estructura WNDCLASSEX, regístrela en Windows para que conozca la ventana y sepa cómo enviarle mensajes. Use la función RegisterClassEx y pase la estructura de clase de ventana como argumento. La macro _T se usa porque usamos el tipo TCHAR según la discusión sobre Unicode anterior. En el código siguiente se muestra cómo registrar la clase de ventana.

   if (!RegisterClassEx(&wcex))
   {
      MessageBox(NULL,
         _T("Call to RegisterClassEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

3. A continuación, cree una ventana mediante la función CreateWindowEx.

   static TCHAR szWindowClass[] = _T("DesktopApp");
   static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
   
   // The parameters to CreateWindowEx explained:
   // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
   // szWindowClass: the name of the application
   // szTitle: the text that appears in the title bar
   // WS_OVERLAPPEDWINDOW: the type of window to create
   // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
   // 500, 100: initial size (width, length)
   // NULL: the parent of this window
   // NULL: this application does not have a menu bar
   // hInstance: the first parameter from WinMain
   // NULL: not used in this application
   HWND hWnd = CreateWindowEx(
   WS_EX_OVERLAPPEDWINDOW,
      szWindowClass,
      szTitle,
      WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT,
      500, 100,
      NULL,
      NULL,
      hInstance,
      NULL
   );
   if (!hWnd)
   {
      MessageBox(NULL,
         _T("Call to CreateWindowEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

   Esta función devuelve HWND, que es un manipulador de una ventana. Un identificador es algo parecido a un puntero. Windows lo usa para realizar un seguimiento de las ventanas que cree. Para obtener más información, vea Tipos de datos de Windows.

4. En este momento, se ha creado la ventana, pero todavía es necesario indicar a Windows que la haga visible. Y eso es lo que hace este código:

   // The parameters to ShowWindow explained:
   // hWnd: the value returned from CreateWindow
   // nCmdShow: the fourth parameter from WinMain
   ShowWindow(hWnd,
      nCmdShow);
   UpdateWindow(hWnd);
   

   La ventana mostrada es simplemente un rectángulo en blanco porque aún no ha implementado la función WndProc. La aplicación aún no controla los mensajes que Windows le envía.

5. Para controlar los mensajes, primero agregamos lo que se denomina un bucle de mensajes para escuchar los mensajes que Windows envía. Cuando la aplicación recibe un mensaje, este bucle lo envía a la función WndProc que se va a controlar. El bucle de mensajes es similar al código siguiente:

   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }
   
   return (int) msg.wParam;
   

   Para más información sobre las estructuras y funciones que se usan en el bucle de mensajes, vea MSG, GetMessage, TranslateMessage y DispatchMessage.

   Una función básica WinMain que crea la ventana principal de la aplicación y escucha mensajes que Windows envía a la aplicación se parecería al siguiente código:

   int WINAPI WinMain(HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPSTR lpCmdLine,
                      int nCmdShow)
   {
      WNDCLASSEX wcex;
   
      wcex.cbSize = sizeof(WNDCLASSEX);
      wcex.style          = CS_HREDRAW | CS_VREDRAW;
      wcex.lpfnWndProc    = WndProc;
      wcex.cbClsExtra     = 0;
      wcex.cbWndExtra     = 0;
      wcex.hInstance      = hInstance;
      wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
      wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
      wcex.lpszMenuName   = NULL;
      wcex.lpszClassName  = szWindowClass;
      wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   
      if (!RegisterClassEx(&wcex))
      {
         MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // Store instance handle in our global variable
      hInst = hInstance;
   
      // The parameters to CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // szWindowClass: the name of the application
      // szTitle: the text that appears in the title bar
      // WS_OVERLAPPEDWINDOW: the type of window to create
      // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
      // 500, 100: initial size (width, length)
      // NULL: the parent of this window
      // NULL: this application dows not have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindow
      // nCmdShow: the fourth parameter from WinMain
      ShowWindow(hWnd, nCmdShow);
      UpdateWindow(hWnd);
   
      // Main message loop:
      MSG msg;
      while (GetMessage(&msg, NULL, 0, 0))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   
      return (int) msg.wParam;
   }
   

Control de mensajes en la función WndProc

1. Para controlar los mensajes que recibe la aplicación, implemente una instrucción switch en la función WndProc.

   Un mensaje importante que se va a controlar es WM_PAINT. La aplicación recibe un mensaje WM_PAINT cuando debe actualizarse parte de su ventana mostrada. El evento puede producirse cuando un usuario mueve una ventana delante de su ventana y lo mueve de nuevo. Recibe este mensaje la primera vez que se muestra la ventana, lo que le da la oportunidad de mostrar la interfaz de usuario de la aplicación. La aplicación descubre estos eventos cuando Windows los envía. Cuando se muestra por primera vez la ventana, toda ella se debe actualizar.

   Para controlar un mensaje WM_PAINT, primero llame a BeginPaint, controle toda la lógica para mostrar el texto, los botones y otros controles de la ventana. A continuación, llame a EndPaint. Para esta aplicación, el código entre BeginPaint() y EndPaint() muestra Hello, Windows desktop! en la ventana que creó en WinMain(). En el código siguiente, la función TextOut muestra el texto en la ubicación especificada en la ventana.

   PAINTSTRUCT ps;
   HDC hdc;
   TCHAR greeting[] = _T("Hello, Windows desktop!");
   
   switch (message)
   {
   case WM_PAINT:
      hdc = BeginPaint(hWnd, &ps);
   
      // Here your application is laid out.
      // For this introduction, we just print out "Hello, Windows desktop!"
      // in the top left corner.
      TextOut(hdc,
         5, 5,
         greeting, _tcslen(greeting));
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   En el código anterior, HDC es un identificador de un contexto de dispositivo que está asociado al área cliente de la ventana. Se usa al dibujar en la ventana para hacer referencia a su área cliente. Use las funciones BeginPaint y EndPaint para preparar y completar el dibujo en el área cliente. BeginPaint devuelve un manipulador para el contexto del dispositivo de visualización utilizado para dibujar en el área cliente; EndPaint finaliza la solicitud de pintura y libera el contexto del dispositivo.

2. Una aplicación normalmente controla muchos otros mensajes. Por ejemplo, WM_CREATE se envía cuando se crea una ventana por primera vez y WM_DESTROY cuando se cierra la ventana. El código siguiente muestra una función WndProc básica pero completa:

   LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
      PAINTSTRUCT ps;
      HDC hdc;
      TCHAR greeting[] = _T("Hello, Windows desktop!");
   
      switch (message)
      {
      case WM_PAINT:
         hdc = BeginPaint(hWnd, &ps);
   
         // Here your application is laid out.
         // For this introduction, we just print out "Hello, Windows desktop!"
         // in the top left corner.
         TextOut(hdc,
            5, 5,
            greeting, _tcslen(greeting));
         // End application specific layout section.
   
         EndPaint(hWnd, &ps);
         break;
      case WM_DESTROY:
         PostQuitMessage(0);
         break;
      default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
      }
   
      return 0;
   }
   

Compilación del código

Como se prometió, el código completo de la aplicación en funcionamiento es el siguiente.

Para compilar este ejemplo

1. Elimine todo el código de HelloWindowsDesktop.cpp en el editor. Copie este código de ejemplo y péguelo en HelloWindowsDesktop.cpp:

   // HelloWindowsDesktop.cpp
   // compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c
   
   #include <windows.h>
   #include <stdlib.h>
   #include <string.h>
   #include <tchar.h>
   
   // Global variables
   
   // The main window class name.
   static TCHAR szWindowClass[] = _T("DesktopApp");
   
   // The string that appears in the application's title bar.
   static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
   
   // Stored instance handle for use in Win32 API calls such as FindResource
   HINSTANCE hInst;
   
   // Forward declarations of functions included in this code module:
   LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
   
   int WINAPI WinMain(
      _In_ HINSTANCE hInstance,
      _In_opt_ HINSTANCE hPrevInstance,
      _In_ LPSTR     lpCmdLine,
      _In_ int       nCmdShow
   )
   {
      WNDCLASSEX wcex;
   
      wcex.cbSize = sizeof(WNDCLASSEX);
      wcex.style          = CS_HREDRAW | CS_VREDRAW;
      wcex.lpfnWndProc    = WndProc;
      wcex.cbClsExtra     = 0;
      wcex.cbWndExtra     = 0;
      wcex.hInstance      = hInstance;
      wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
      wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
      wcex.lpszMenuName   = NULL;
      wcex.lpszClassName  = szWindowClass;
      wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   
      if (!RegisterClassEx(&wcex))
      {
         MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // Store instance handle in our global variable
      hInst = hInstance;
   
      // The parameters to CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // szWindowClass: the name of the application
      // szTitle: the text that appears in the title bar
      // WS_OVERLAPPEDWINDOW: the type of window to create
      // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
      // 500, 100: initial size (width, length)
      // NULL: the parent of this window
      // NULL: this application does not have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindow
      // nCmdShow: the fourth parameter from WinMain
      ShowWindow(hWnd,
         nCmdShow);
      UpdateWindow(hWnd);
   
      // Main message loop:
      MSG msg;
      while (GetMessage(&msg, NULL, 0, 0))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   
      return (int) msg.wParam;
   }
   
   //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
   //
   //  PURPOSE:  Processes messages for the main window.
   //
   //  WM_PAINT    - Paint the main window
   //  WM_DESTROY  - post a quit message and return
   LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
      PAINTSTRUCT ps;
      HDC hdc;
      TCHAR greeting[] = _T("Hello, Windows desktop!");
   
      switch (message)
      {
      case WM_PAINT:
         hdc = BeginPaint(hWnd, &ps);
   
         // Here your application is laid out.
         // For this introduction, we just print out "Hello, Windows desktop!"
         // in the top left corner.
         TextOut(hdc,
            5, 5,
            greeting, _tcslen(greeting));
         // End application-specific layout section.
   
         EndPaint(hWnd, &ps);
         break;
      case WM_DESTROY:
         PostQuitMessage(0);
         break;
      default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
      }
   
      return 0;
   }
   

2. En el menú Compilar , elija Compilar solución. Los resultados de la compilación aparecen en la ventana Salida de Visual Studio.

   

   La animación muestra cómo hacer clic en el botón Guardar todo y, a continuación, elegir Compilar > Compilar solución en el menú principal.

3. Para ejecutar la aplicación, presione F5. Debería aparecer una ventana con el texto "Hello, Windows desktop!".

   

Felicidades. Ha creado una aplicación de escritorio tradicional de Windows.

Consulte también

Tipos de aplicación de escritorio de Windows C++