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 criado usa a API do Windows para exibir o Hello, á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 de área de trabalho do Windows.

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

Importante

Os blocos de código em The code são trechos explicativos, não passos para você colar à medida que avança. Eles omitem o código de suporte para que cada conceito seja mais fácil de ver. Depois de criar o projeto vazio, use o código-fonte completo e compilável em Compilar o código.

Pré-requisitos

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

• Visual Studio. Para saber mais sobre como fazer o download e instalar o Visual Studio, consulte Instalar o Visual Studio. Quando executar o instalador, certifique-se de que a carga de trabalho de Desenvolvimento para desktop com C++ esteja marcada. Não se preocupe se não tiver instalado essa carga de trabalho quando instalou o Visual Studio. Você pode executar o instalador novamente e instalá-la agora.

  

• Uma compreensão básica de como usar o IDE do Visual Studio. Se você já usou aplicativos para desktop do Windows antes, provavelmente conseguirá acompanhar. Para ver uma introdução, consulte Tour pelos recursos do IDE do Visual Studio.

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

Criar um projeto de área de trabalho do Windows

Siga estas etapas para criar seu primeiro projeto da área de trabalho do Windows. Não cole os trechos individuais de código à medida que avança. Depois de criar o projeto, use o código-fonte completo em Compile o código.

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

Para criar um projeto da á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 projeto.

2. Na parte superior da caixa de diálogo, defina Linguagem como C++, Plataforma como Windows e Tipo de projeto como Desktop.

3. Na lista filtrada de tipos de projeto, escolha Assistente para Área de Trabalho do Windows e escolha Avançar. Na página a seguir, insira o nome do 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 Aplicativo, certifique-se de selecionar aplicativo de área de trabalho (.exe). Como estamos criando um aplicativo para Windows, escolher Aplicativo de Console resulta em um projeto que não poderá ser compilado com o código que vamos usar. Em seguida, em Opções adicionais, selecione Projeto vazio. Clique em OK para criar o projeto.

6. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto DesktopApp, escolha Adicionar e 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 que aparece 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 está criado e seu arquivo de origem é aberto no editor.

O código

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

Como o programa se encaixa

Um aplicativo de área de trabalho Windows tradicional usa várias partes do código de instalação antes de exibir uma janela:

Parte do programa	Purpose
Cabeçalhos e declarações compartilhadas	Fornece tipos do Windows e declara valores usados por várias funções.
WinMain	Registra a classe de janela, cria e exibe a janela e executa o loop de mensagem.
WndProc	Processa mensagens de Windows, como solicitações para pintar ou fechar a janela.

Os trechos a seguir se concentram em uma parte do programa de cada vez. A origem completa combina as partes na ordem certa.

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

1. Assim como todos os aplicativos C e C++ precisam ter uma função main como ponto de partida, cada aplicativo da área de trabalho do Windows precisa ter uma função WinMain. 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 retornado dessa função, confira ponto de entrada WinMain.

   Observação

   O que 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 dos tipos e do código específico da plataforma, como convenções de chamada, declarações __declspec e pragmas do 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, veja Usando o IntelliSense. Parâmetros e tipos de retorno geralmente usam Anotações SAL para ajudar a detectar erros de programação. Para obter mais informações, confira Como usar anotações da SAL para reduzir defeitos de código C/C++.

2. Os programas da área de trabalho do Windows exigem <windows.h>. Você vê #include <tchar.h> com frequência também. Isso é para facilitar a criação de um aplicativo que possa funcionar com char ou wchar_t. A maneira como ela funciona é que, em vez disso, você usa a TCHAR macro em seu código. TCHAR resolve para wchar_t quando seu projeto define o UNICODE símbolo; caso contrário, ele resolve para char. Se você sempre compilar com o UNICODE habilitado, não precisará de TCHAR e poderá usar wchar_t diretamente. Para obter mais informações, consulte Usar mapeamentos de texto genérico. O código a seguir mostra essas duas #include declarações no topo do arquivo.

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

3. Ao lado da função WinMain, todos os aplicativos da área de trabalho do Windows também precisam ter uma função de procedimento de janela. Este passo a passo nomeia a função WndProc, mas você pode dar a ela 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
   );
   

   Nessa função, você escreve código para lidar com mensagens que o aplicativo recebe do Windows quando ocorrem eventos. Por exemplo, se um usuário selecionar o botão OK em seu aplicativo, o Windows enviará uma mensagem para você. Você escreve código dentro de uma função WndProc que faz o trabalho que for apropriado. Chamamos isso de tratar um evento. Você só lida com os eventos que são relevantes para o seu aplicativo.

   Para obter mais informações, confira Procedimentos do Windows.

Adicionar funcionalidade à função WinMain

Antes WinMain, declare os valores e o procedimento de janela que outras partes do programa usam. Essas declarações aparecem antes de WinMain no código-fonte 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. Na função WinMain, você precisa capturar algumas informações básicas sobre a janela principal. Para isso, preencha uma estrutura do tipo WNDCLASSEX. A estrutura contém informações sobre a janela, como o ícone do aplicativo, a cor da tela de fundo da janela, o nome a ser exibido na barra de título, entre outras coisas. É importante ressaltar que ela contém um ponteiro de função para o procedimento da janela que trata as mensagens que o Windows envia para o seu aplicativo. O exemplo a seguir mostra uma estrutura WNDCLASSEX típica:

   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 preencher a estrutura WNDCLASSEX, registre-a no Windows para que ele reconheça sua janela e saiba como enviar mensagens para ela. Use a função RegisterClassEx e passe a estrutura de classe da janela como argumento. A macro _T faz com que o literal de cadeia de caracteres corresponda ao tipo de caractere selecionado por TCHAR, conforme descrito na discussão anterior sobre Unicode. O código a seguir mostra como registrar a classe de janela.

   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.

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

   Essa função retorna um HWND, que é um identificador para uma janela. Um identificador é semelhante a um ponteiro. O Windows o utiliza para manter o controle das janelas que você cria. Para mais informações, confira Tipos de dados do Windows.

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

   // The parameters to ShowWindow explained:
   // hWnd: the value returned from CreateWindowEx
   // 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 função WndProc. O aplicativo ainda não está tratando as mensagens que o Windows está enviando para ele.

5. Para tratar as mensagens, primeiro adicionamos o que chamamos de loop de mensagem para ouvir as mensagens que o Windows envia. Quando o aplicativo recebe uma mensagem, esse loop a envia para sua função WndProc a ser tratada. O loop de mensagens se parece com o código a seguir:

   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 do loop de mensagens, consulte MSG, GetMessage, TranslateMessage e DispatchMessage.

   Uma função WinMain básica que cria a janela principal do aplicativo e escuta as mensagens que o Windows envia ao seu aplicativo seria semelhante ao código a seguir:

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

Tratamento de mensagens na função WndProc

1. Para tratar as mensagens que o aplicativo recebe, implemente uma instrução switch em sua função WndProc.

   Uma mensagem importante a ser tratada é WM_PAINT. O aplicativo recebe uma mensagem WM_PAINT quando parte da janela exibida precisa ser atualizada. O evento pode ocorrer quando um usuário move uma janela para a frente da sua janela e a afasta novamente. Ele recebe essa mensagem na primeira vez em que a sua janela é exibida, o que dá a você a chance de exibir a interface do usuário do aplicativo. Seu aplicativo fica sabendo desses eventos quando o Windows os envia. Quando a janela é exibida pela primeira vez, tudo isso precisa ser atualizado.

   Para tratar uma mensagem WM_PAINT, primeiro chame BeginPaint e, em seguida, trate de toda a lógica para dispor o texto, os botões e outros controles na janela. Em seguida, chame EndPaint. Nesse aplicativo, o código entre BeginPaint() e EndPaint() exibe Hello, Windows desktop! na janela que você criou em WinMain(). No código a seguir, a função TextOut 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, 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;
   }
   

   No código anterior, HDC é um identificador para um contexto de dispositivo associado à área cliente da janela. Ao desenhar na janela, use este identificador para fazer referência à área do cliente. Use as funções BeginPaint e EndPaint para preparar e concluir o desenho na área de 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. Normalmente, um aplicativo 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 WndProc básica, mas 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;
   }
   

Compilar o código

Conforme prometido, segue o código completo do aplicativo em funcionamento.

Para criar este exemplo

1. Exclua todo o código no HelloWindowsDesktop.cpp no editor. 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 <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. No menu Compilar, escolha Compilar Solução. Os resultados da compilação aparecem na janela Saída do Visual Studio.

   

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

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

   

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

Confira também

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