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

Artículo
08/08/2022
Tiempo de lectura: 15 minutos

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

La API de Windows (también conocida como API de Win32, Windows Desktop API y Windows API clásica) es un marco basado en lenguaje C para crear aplicaciones Windows. Ha existido desde la década de 1980 y se ha usado para crear aplicaciones Windows durante décadas. Los marcos de trabajo más avanzados y más fáciles de programar se han creado sobre la API de Windows. Por ejemplo, MFC, ATL, .NET Frameworks. Incluso el código de Windows Runtime más moderno para aplicaciones para UWP y Store escritas en C++/WinRT usa la API de Windows debajo. Para más información sobre la API de Windows, consulte Windows índice de API. Hay muchas maneras de crear Windows aplicaciones, pero el proceso anterior fue el primero.

Importante

Por motivos de brevedad, algunas instrucciones de código se omiten en el texto. La sección Compilar el código al final de este documento muestra el código completo.

Requisitos previos

Un equipo que ejecuta Microsoft Windows 7 o versiones posteriores. Se recomienda Windows 10 o 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.
Comprensión de los aspectos básicos del uso de 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. A medida que vaya, escribirá el código para una aplicación de escritorio de Windows en funcionamiento. 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

En el menú principal, seleccione Archivo>Nuevo>Proyecto para abrir el cuadro de diálogo Crear nuevo proyecto.
En la parte superior del cuadro de diálogo, establezca Lenguaje en C++, establezca Plataformaen Windows y establezca Project tipo en Escritorio.
En la lista filtrada de tipos de proyecto, elija Windows Asistente para escritorio y, a continuación, elija Siguiente. En la página siguiente, escriba un nombre para el proyecto, por ejemplo DesktopApp.
Elija el botón Crear para crear el proyecto.
Ahora aparece el cuadro de diálogo Project de escritorio Windows. En Tipo de aplicación, seleccione Aplicación de escritorio (.exe). En Opciones adicionales, seleccione Proyecto vacío. Seleccione Aceptar para crear el proyecto.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto DesktopApp, elija Agregar y, a continuación, elija Nuevo elemento.
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. Seleccione Agregar.

El proyecto ahora se crea y el archivo de origen se abre en el editor. Para continuar, vaya directamente a Crear el código.

Para crear un proyecto de escritorio de Windows en Visual Studio 2017

En el menú Archivo, elija Nuevo y después Proyecto.
En el cuadro de diálogo Nuevo Project, en el panel izquierdo, expanda InstaladoVisual>C++y, a continuación, seleccione Windows Escritorio. En el panel central, seleccione Windows Asistente para escritorio.

En el cuadro Nombre , escriba un nombre para el proyecto, por ejemplo , DesktopApp. Elija Aceptar.
En el cuadro de diálogo Project de escritorio de Windows, en Tipo de aplicación, seleccione Windows aplicación (.exe). En Opciones adicionales, seleccione Proyecto vacío. Asegúrese de que el encabezado precompilado no está seleccionado. Seleccione Aceptar para crear el proyecto.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto DesktopApp, elija Agregar y, a continuación, elija Nuevo elemento.
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. Seleccione Agregar.

El proyecto ahora se crea y el archivo de origen se abre en el editor. Para continuar, vaya directamente a Crear el código.

Para crear un proyecto de escritorio de Windows en Visual Studio 2015

En el menú Archivo, elija Nuevo y después Proyecto.
En el cuadro de diálogo Nuevo Project, en el panel izquierdo, expanda InstalledTemplatesVisual>>C++y, a continuación, seleccione Win32. En el panel central, seleccione Proyecto Win32.

En el cuadro Nombre , escriba un nombre para el proyecto, por ejemplo , DesktopApp. Elija Aceptar.
En la página Información general del Asistente para aplicaciones Win32, elija Siguiente.
En la página Application Configuración (Aplicación Configuración), en Tipo de aplicación, seleccione Windows aplicación. En Opciones adicionales, desactive Encabezado precompilado y, a continuación, seleccione Proyecto vacío. Haga clic en Finalizar para crear el proyecto.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto DesktopApp, elija Agregar y, a continuación, elija Nuevo elemento.
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. Seleccione Agregar.

El proyecto ahora se crea y el archivo de origen se abre en el editor.

Creación del código

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

Para iniciar una aplicación de escritorio de Windows

Al igual que todas las aplicaciones de C y de C++ deben tener una main función como punto de partida, cada Windows aplicación de escritorio debe tener una WinMain función. WinMain tiene la siguiente sintaxis.
```
int WINAPI WinMain(
   _In_ HINSTANCE hInstance,
   _In_opt_ HINSTANCE hPrevInstance,
   _In_ LPSTR     lpCmdLine,
   _In_ int       nCmdShow
);
```
Para obtener información sobre los parámetros y el valor devuelto de esta función, vea Punto de entrada de WinMain.

Nota:

¿Cuáles son todas esas palabras adicionales, como , o CALLBACK, o _In_HINSTANCE?WINAPI La API de Windows tradicional usa definiciones de tipo y macros de preprocesador ampliamente para abstraer algunos de los detalles de tipos y código específico de la plataforma, como las convenciones de llamada, __declspec las declaraciones y las pragmas del compilador. En Visual Studio, puede usar la característica Información rápida de IntelliSense para ver cuáles son estas definiciones de tipo y macros. Mantenga el mouse sobre la palabra de interés o selecciónelo y presione CtrlK+,CtrlI+ para una pequeña ventana emergente que contenga la definición. Para obtener 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 obtener más información, vea Uso de anotaciones SAL para reducir defectos de código de C/C++.
Windows los programas de escritorio requieren <windows.h>. <tchar.h> define la TCHAR macro, que se resuelve en última instancia en wchar_t si el símbolo UNICODE se define en el proyecto; de lo contrario, se resuelve charen . Si siempre compila con UNICODE habilitado, no necesita TCHAR y solo puede usar wchar_t directamente.
```
#include <windows.h>
#include <tchar.h>
```
Junto con la WinMain función , todas las Windows aplicación de escritorio también deben tener una función de procedimiento de ventana. Esta función se suele denominar WndProc, pero puede asignarle el nombre que quiera. WndProc tiene la siguiente sintaxis.
```
LRESULT CALLBACK WndProc(
   _In_ HWND   hWnd,
   _In_ UINT   message,
   _In_ WPARAM wParam,
   _In_ LPARAM lParam
);
```
En esta función, se escribe 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 enviará un mensaje y podrá escribir código dentro de la WndProc función que haga lo que sea adecuado. Se denomina control de un evento. Solo controla los eventos pertinentes para la aplicación.

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

Para agregar funcionalidad a la función WinMain

En la WinMain función , se rellena una estructura de tipo WNDCLASSEX. La estructura contiene información sobre la ventana: 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. Lo importante es que contiene un puntero de función al procedimiento de ventana. 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 la estructura anterior, vea WNDCLASSEX.

Registre con WNDCLASSEX 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 se usa porque usamos el TCHAR tipo .
```
if (!RegisterClassEx(&wcex))
{
   MessageBox(NULL,
      _T("Call to RegisterClassEx failed!"),
      _T("Windows Desktop Guided Tour"),
      NULL);

   return 1;
}
```

Ahora puede crear una ventana. Use 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 un , HWNDque es un identificador de una ventana. Un identificador es algo parecido a un puntero que Windows usa para realizar un seguimiento de las ventanas abiertas. Para obtener más información, vea Tipos de datos de Windows.

En este momento, se ha creado la ventana, pero todavía es necesario indicar Windows para que sea visible. 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 no tiene mucho contenido porque aún no ha implementado la WndProc función. En otras palabras, la aplicación aún no controla los mensajes que Windows está enviando a él.

Para controlar los mensajes, primero se agrega 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 WndProc función 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, TranslateMessagey DispatchMessage.

En este punto, la función WinMain debe ser similar al código siguiente.

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

Para agregar funcionalidad a la función WndProc

Para habilitar la función WndProc a fin de controlar los mensajes que recibe la aplicación, implemente una instrucción switch.

Un mensaje importante que se debe controlar es el mensaje WM_PAINT . La aplicación recibe el WM_PAINT mensaje cuando se debe actualizar parte de su ventana mostrada. El evento puede producirse cuando un usuario mueve una ventana delante de la ventana y, a continuación, lo mueve de nuevo. La aplicación no sabe cuándo se producen estos eventos. Solo Windows sabe, por lo que notifica a la aplicación un WM_PAINT mensaje. Cuando se muestra por primera vez la ventana, se deben actualizar todas.

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 y luego llame a EndPaint. Para la aplicación, la lógica entre la llamada inicial y la llamada final muestra la cadena "Hello, Windows desktop!" en la ventana. En el código siguiente, se usa la función TextOut para mostrar la cadena.
```
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;
}
```
HDC en el código es un identificador de un contexto de dispositivo, que se usa para dibujar en el área cliente de la ventana. Use las BeginPaint funciones y EndPaint para preparar y completar el dibujo en el área cliente. BeginPaint devuelve un identificador al 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.

Normalmente, una aplicación controla muchos otros mensajes. Por ejemplo, WM_CREATE 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ó, este es el código completo para la aplicación en funcionamiento.

Para compilar este ejemplo

Elimine cualquier código que haya escrito 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 <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;
}

En el menú Compilar , elija Compilar solución. Los resultados de la compilación deben aparecer en la ventana Salida de Visual Studio.
Para ejecutar la aplicación, presione F5. Una ventana que contiene el texto "Hello, Windows desktop!" debe aparecer en la esquina superior izquierda de la pantalla.

¡Enhorabuena! Ha completado este tutorial y ha creado una aplicación de escritorio de Windows tradicional.

Consulta también

Aplicaciones de escritorio de Windows