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

En este tutorial se explica cómo crear una aplicación de escritorio tradicional de Windows en Visual Studio. La aplicación que crea usa la API de Windows para mostrar Hello, Escritorio de Windows! 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, los marcos 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.

Requisitos previos

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

• Visual Studio. Para obtener información sobre cómo descargar e instalar Visual Studio, consulte Instalación de Visual Studio. Al ejecutar el instalador, asegúrese de que la carga de trabajo Desarrollo para el escritorio con C++ esté seleccionada. 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 cómo usar el IDE de Visual Studio. Si has usado antes aplicaciones de escritorio para Windows, probablemente puedas seguir el ritmo. Para ver una introducción, consulte Paseo por las características del IDE de Visual Studio.

• Cierta familiaridad con el lenguaje C++. 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. No pegue los extractos de código individuales a medida que vaya. Después de crear el proyecto, use el origen completo en Compilación del código.

Para ver los pasos de la versión preferida de Visual Studio, use el selector versión situado en la parte superior de la tabla de contenido de esta página.

El código.

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

Cómo encaja el programa

Una aplicación de escritorio de Windows tradicional usa varios fragmentos de código de configuración antes de que pueda mostrar una ventana:

Los siguientes extractos se centran en una parte del programa a la vez. El origen completo combina las partes en el orden correcto.

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 tradicional de Windows utiliza ampliamente definiciones de tipo y macros del preprocesador para abstraer algunos de los detalles de los tipos y del código específico de la plataforma, como las convenciones de llamada, las declaraciones __declspec y las directivas pragma 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 retorno suelen utilizar anotaciones SAL para ayudar 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ás #include <tchar.h> con frecuencia. Esto es para facilitar la escritura de una aplicación que pueda funcionar con char o wchar_t. Funciona de la siguiente manera: en su lugar, usas la macro TCHAR en tu código. TCHAR se convierte en wchar_t cuando su proyecto define el símbolo UNICODE; de lo contrario, se convierte en 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 #include instrucciones 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. En esta guía, la función se llama WndProc, pero en tu código puedes darle el nombre que quieras. 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. Escribes código dentro de una función WndProc que realiza el trabajo que corresponda. Esto se conoce como controlar un evento. Solo gestionas los eventos que son relevantes para tu aplicación.

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

Agregar funcionalidad a la función WinMain

Antes de WinMain, declare los valores y el procedimiento de ventana que utilizan otras partes del programa. Estas declaraciones aparecen antes WinMain en el origen completo:

// 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;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

1. En la función WinMain, debe capturar información básica sobre la ventana principal. Para ello, rellene una estructura de tipo WNDCLASSEX. La estructura contiene información sobre la ventana, como el icono de la aplicación, el color de fondo de la ventana, el nombre que se va a mostrar en la barra de título, entre otras cosas. 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 obtener información sobre los campos de esta estructura, vea WNDCLASSEX.

2. Una vez que haya rellenado la WNDCLASSEX estructura, regístrela con Windows para que sepa sobre la ventana y cómo enviar mensajes a ella. Use la función RegisterClassEx y pase la estructura de clase de ventana como argumento. La _T macro hace que el literal de cadena coincida con el tipo de carácter seleccionado por TCHAR, como se describe en la explicación anterior sobre Unicode. 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. Cree una ventana mediante la CreateWindowEx función .

   // 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, height)
   // NULL: the parent of this window
   // NULL: this application doesn't 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 un HWND, que es un identificador 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 CreateWindowEx
   // 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 su función WndProc para que se procese. 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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't 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;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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;
   }
   

Gestionar 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 hay que gestionar 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 por delante de su ventana y luego la aparta 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   En el código anterior, HDC es un descriptor de un contexto de dispositivo asociado al área cliente de la ventana. Cuando dibujes en la ventana, utiliza este identificador para hacer referencia al área de cliente. Use las funciones BeginPaint y EndPaint para preparar y completar el dibujo en el área cliente. BeginPaint devuelve un identificador para el contexto de dispositivo de pantalla utilizado para dibujar en el área de cliente; EndPaint finaliza la operación de pintado y libera el contexto de 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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 en 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 <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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't 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;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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++