Passo a passo: Criar um aplicativo de área de trabalho tradicional do Windows (C++)

Este passo a passo explica como criar um aplicativo de área de trabalho tradicional do Windows no Visual Studio. O aplicativo que você cria usa a API do Windows para exibir Olá, área de trabalho do Windows! em uma janela. Você pode usar o código desenvolvido neste passo a passo como um padrão para criar aplicativos da área de trabalho do Windows.

A API do Windows (também conhecida como API Win32, API da Área de Trabalho do Windows e API Clássica do Windows) é uma estrutura baseada em linguagem C para a criação de aplicativos do Windows. Ele tem sido usado para criar aplicativos do Windows por décadas. Estruturas mais avançadas e mais fáceis de programar foram criadas sobre a API do Windows, por exemplo, as estruturas MFC, ATL e .NET. Mesmo o código mais moderno do Runtime do Windows para aplicações UWP e Store escritas em C++/WinRT usa a API do Windows subjacente. Para obter mais informações sobre a API do Windows, consulte Índice da API do Windows.

Importante

A seção Criar o código no final deste artigo mostra o código completo. Este passo a passo abrange as várias partes de código que entram em um aplicativo do Windows, mas alguns detalhes são omitidos nos trechos de código para se concentrar nas partes mais importantes. Você pode copiar o código completo e colá-lo em seu projeto no final.

Pré-requisitos

• Microsoft Windows 7 ou versões posteriores. Recomendamos o Windows 11 ou posterior para a melhor experiência de desenvolvimento.

• Visual Studio. Para obter informações sobre como baixar e instalar o Visual Studio, consulte Instalar o Visual Studio. Ao executar o instalador, certifique-se de que a carga de trabalho Desktop development with C++ está seleccionada. Não se preocupe se você não instalou essa carga de trabalho quando instalou o Visual Studio. Você pode executar o instalador novamente e instalá-lo agora.

  

• Uma compreensão básica de como usar o IDE do Visual Studio. Se já utilizou aplicações de ambiente de trabalho do Windows antes, provavelmente consegue manter-se atualizado. Para obter uma introdução, consulte Tour de recursos do IDE do Visual Studio.

• Alguma familiaridade com a linguagem C++. Não se preocupe, não fazemos nada muito complicado.

Criar um projeto de área de trabalho do Windows

Siga estas etapas para criar seu primeiro projeto de área de trabalho do Windows. Conforme observado no início deste artigo, o código concluído está disponível na seção Criar o código no final do passo a passo. Vá em frente e siga as etapas para criar o projeto, mas aguarde antes de colar as seguintes seções de código até ao final, quando o código completo da aplicação for apresentado. Alguns detalhes são omitidos nos trechos de código para se concentrar nas partes mais importantes. Você pode copiar o código completo e colá-lo em seu projeto no final.

Para ver as etapas para sua versão preferida do Visual Studio, use o seletor de versão localizado na parte superior do sumário nesta página.

Para criar um projeto de área de trabalho do Windows no Visual Studio

1. No menu principal, escolha Arquivo>Novo>Projeto para abrir a caixa de diálogo Criar um Novo Projeto .

2. Na parte superior da caixa de diálogo, defina Language como C++, defina Platform como Windows e defina Project type como Desktop.

3. Na lista filtrada de tipos de projeto, escolha Assistente de Área de Trabalho do Windows e, em seguida, escolha Avançar. Na página seguinte, insira um nome para o projeto, por exemplo, DesktopApp.

4. Escolha o botão Criar para criar o projeto.

5. A caixa de diálogo Projeto da Área de Trabalho do Windows agora é exibida. Na lista suspensa Tipo de aplicação, selecione Aplicação de ambiente de trabalho (.exe). Como estamos a criar uma aplicação do Windows, escolher Aplicação de Consola resulta num projeto que não será compilado com o código que pretendemos utilizar. Em seguida, em Opções adicionais, selecione Projeto vazio. Escolha OK para criar o projeto.

6. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto DesktopApp , escolha Adicionar e, em seguida, escolha Novo Item.

   

   A animação mostra o clique com o botão direito do mouse no nome do projeto no Gerenciador de Soluções, escolhendo Adicionar no menu exibido e, em seguida, escolhendo Novo Item.

7. Na caixa de diálogo Adicionar Novo Item, selecione Arquivo C++ (.cpp). Na caixa Nome , digite um nome para o arquivo, por exemplo, HelloWindowsDesktop.cpp. Escolha Adicionar.

   

Seu projeto agora é criado e seu arquivo de origem é aberto no editor.

O código

Em seguida, saiba como criar o código para um aplicativo da área de trabalho do Windows no Visual Studio.

Onde o código começa a ser executado em um aplicativo da área de trabalho do Windows

1. Assim como todo aplicativo C e aplicativo C++ deve ter uma main função como ponto de partida, todo aplicativo da área de trabalho do Windows deve ter uma WinMain função. WinMain tem a seguinte sintaxe.

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

   Para obter informações sobre os parâmetros e o valor de retorno dessa função, consulte Ponto de entrada WinMain.

   Observação

   Quais são todas essas palavras extras, como WINAPI, ou CALLBACK, ou HINSTANCE, ou _In_? A API tradicional do Windows usa typedefs e macros de pré-processador extensivamente para abstrair alguns dos detalhes de tipos e códigos específicos da plataforma, como convenções de chamada, __declspec declarações e pragmas de compilador. No Visual Studio, você pode usar o recurso Informações rápidas do IntelliSense para ver o que esses typedefs e macros definem. Passe o mouse sobre a palavra de interesse ou selecione-a e pressione Ctrl+K, Ctrl+I para uma pequena janela pop-up que contém a definição. Para obter mais informações, consulte Usando o IntelliSense. Parâmetros e tipos de retorno geralmente usam anotações SAL para ajudá-lo a detetar erros de programação. Para obter mais informações, consulte Usando anotações SAL para reduzir defeitos de código C/C++.

2. Os programas de ambiente de trabalho do Windows requerem <windows.h>. Você também vê #include <tchar.h> com frequência. Isso é para tornar mais fácil escrever um aplicativo que pode funcionar com qualquer um char ou wchar_t. A forma como funciona é que em vez disso utiliza-se a macro TCHAR no código, que se resolve finalmente para wchar_t se o símbolo UNICODE for definido no seu projeto; caso contrário, ela resolve para char. Se você sempre construir com UNICODE habilitado, você não precisa TCHAR e pode apenas usar wchar_t diretamente. Para obter mais informações, consulte Usando mapeamentos de texto genérico. O código a seguir mostra estas duas #include instruções no topo do arquivo.

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

3. Juntamente com a função WinMain, cada aplicação da área de trabalho do Windows deve ter também uma função de procedimento de janela. Esta função é chamada de WndProc, mas você pode dar-lhe o nome que quiser em seu código. WndProc tem a seguinte sintaxe.

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

   Nesta função, você escreve código para manipular mensagens que o aplicativo recebe do Windows quando ocorrem eventos . Por exemplo, se um usuário escolher um botão OK em seu aplicativo, o Windows enviará uma mensagem para você. Você escreve código dentro de uma WndProc função que realiza o trabalho adequado. Chama-se gestão de um evento. Você lida apenas com os eventos que são relevantes para seu aplicativo.

   Para obter mais informações, consulte Window Procedures.

Adicionar funcionalidade à WinMain função

1. WinMain Na função, você precisa capturar algumas informações básicas sobre sua janela principal. Você faz isso preenchendo uma estrutura do tipo WNDCLASSEX. A estrutura contém informações sobre a janela, como o ícone do aplicativo, a cor de fundo da janela, o nome a ser exibido na barra de título, entre outras coisas. É importante ressaltar que ele contém um ponteiro de função para o procedimento da janela que lida com as mensagens que o Windows envia para seu aplicativo. O exemplo a seguir mostra uma estrutura típica 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 obter informações sobre os campos dessa estrutura, consulte WNDCLASSEX.

2. Depois de ter a WNDCLASSEX estrutura preenchida, você a registra no Windows para que ele saiba sobre sua janela e como enviar mensagens para ela. Use a RegisterClassEx função e passe a estrutura de classe da janela como um argumento. A _T macro é usada porque usamos o TCHAR tipo de acordo com a discussão anterior sobre Unicode. O código a seguir mostra como registrar a classe window.

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

3. Crie uma janela usando a CreateWindowEx função.

   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 função retorna um HWND, que é um identificador para uma janela. Uma alça é um pouco como um ponteiro. O Windows usa-o para controlar as janelas que você cria. Para obter mais informações, consulte Tipos de dados do Windows.

4. Neste ponto, a janela foi criada, mas ainda precisamos informar o Windows de que deve torná-la visível. É isso que este código faz:

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

   A janela exibida é apenas um retângulo em branco porque você ainda não implementou a WndProc função. O aplicativo ainda não está lidando com as mensagens que o Windows está enviando para ele.

5. Para lidar com as mensagens, primeiro adicionamos o que é chamado de loop de mensagens para ouvir as mensagens enviadas pelo Windows. Quando o aplicativo recebe uma mensagem, esse loop a envia para sua WndProc função a ser tratada. O loop de mensagem é semelhante ao seguinte código:

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

   Para obter mais informações sobre as estruturas e funções no loop de mensagens, consulte MSG, GetMessage, TranslateMessage e DispatchMessage.

   Uma função básica WinMain que cria a janela principal do aplicativo e escuta as mensagens que o Windows envia ao seu aplicativo seria semelhante ao seguinte 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;
   }
   

Manipular mensagens na função WndProc

1. Para lidar com mensagens que o aplicativo recebe, você implementa uma switch instrução em sua WndProc função.

   Uma mensagem importante a lidar com é WM_PAINT. O aplicativo recebe uma WM_PAINT mensagem quando parte de sua janela exibida deve ser atualizada. O evento pode ocorrer quando um utilizador move uma janela na frente da sua janela e a afasta novamente. Ele recebe essa mensagem na primeira vez que sua janela é exibida, dando-lhe a chance de exibir a interface do usuário do aplicativo. Seu aplicativo descobre esses eventos quando o Windows os envia. Quando a janela é exibida pela primeira vez, toda ela deve ser atualizada.

   Para lidar com uma WM_PAINT mensagem, primeiro chame BeginPainte, em seguida, manipule toda a lógica para dispor o texto, botões e outros controles na janela. Em seguida, ligue para EndPaint. Para este aplicativo, o código entre BeginPaint() e EndPaint() é exibido Hello, Windows desktop! na janela que você criou em WinMain(). No código a seguir, a TextOut função exibe o texto no local especificado na janela.

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

   No código anterior, HDC é um identificador para um contexto de dispositivo que está associado com a área do cliente da janela. Você usa ao desenhar na janela para se referir à sua área do cliente. Use as funções BeginPaint e EndPaint para preparar e completar o desenho na área do cliente. BeginPaint retorna um identificador para o contexto do dispositivo de exibição usado para desenhar na área do cliente; EndPaint encerra a solicitação de pintura e libera o contexto do dispositivo.

2. Um aplicativo normalmente lida com muitas outras mensagens. Por exemplo, WM_CREATE é enviado quando uma janela é criada pela primeira vez e WM_DESTROY quando a janela é fechada. O código a seguir mostra uma função básica, mas completa WndProc :

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

Compilar o código

Como prometido, o código completo para o aplicativo de trabalho segue.

Para criar este exemplo

1. No editor, exclua todo o código em HelloWindowsDesktop.cpp. Copie este código de exemplo e cole-o em 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. No menu Build , escolha Build Solution. Os resultados da compilação aparecem na janela Saída no Visual Studio.

   

   A animação mostra clicar no botão Salvar tudo e, em seguida, escolher Compilar > Compilar Solução no menu principal.

3. Para executar o aplicativo, pressione F5. Deve aparecer uma janela com o texto Hello, Windows desktop! .

   

Parabéns! Você criou um aplicativo de área de trabalho tradicional do Windows.

Ver também

• Tipos de aplicativos da área de trabalho do Windows C++