Passo a passo: Criar um aplicativo tradicional da Área de Trabalho do Windows (C++)

Este passo a passo mostra como criar um aplicativo de área de trabalho tradicional do Windows no Visual Studio. O aplicativo de exemplo que você criará usa a API do Windows para exibir "Olá, área de trabalho do Windows!" em uma janela. Você pode usar o código que desenvolve neste passo a passo como um padrão para criar outros aplicativos da á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 existe desde a década de 1980 e é usado para criar aplicativos do Windows há décadas. Estruturas mais avançadas e fáceis de programar foram criadas com base na API do Windows. Por exemplo, MFC, ATL, as estruturas .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. Há muitas maneiras de criar aplicativos do Windows, mas o processo acima foi o primeiro.

Importante

Para fins de brevidade, algumas instruções de código são omitidas no texto. A seção Criar o código no final deste documento mostra o código completo.

Pré-requisitos

  • Um computador que executa o Microsoft Windows 7 ou versões posteriores. Recomendamos o Windows 10 ou posterior para obter a melhor experiência de desenvolvimento.

  • Uma cópia do 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.

    Detalhe do desenvolvimento da área de trabalho com carga de trabalho C++ no Instalador do Visual Studio.

  • Um reconhecimento dos princípios básicos do uso do IDE do Visual Studio. Se já tiver usado aplicativos de desktop do Windows, você provavelmente não terá problemas. Para ver uma introdução, consulte Tour pelos recursos do IDE do Visual Studio.

  • Um reconhecimento dos princípios básicos da linguagem C++ a seguir. 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. No processo, você inserirá o código para um aplicativo de área de trabalho do Windows. Para ver a documentação de sua versão preferida do Visual Studio, use o controle seletor de Versão. Ele é encontrado 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. O assistente Projeto do Windows Desktop agora é exibido. Em Tipo de aplicativo, selecione Aplicativo de área de trabalho (.exe). 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.

    Vídeo curto que mostra o usuário adicionando um novo item ao Projeto DesktopApp no Visual Studio 2019.

  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.

    Captura de tela na caixa de diálogo “Adicionar novo item” no Visual Studio 2019 com Instalado e Visual C mais mais selecionado e a opção C mais mais em destaque.

Seu projeto agora está criado e seu arquivo de origem é aberto no editor. Para continuar, pule para Criar o código.

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

  1. No menu Arquivo, escolha Novo e, em seguida, clique em Projeto.

  2. Na caixa de diálogo Novo Projeto, no painel esquerdo, expanda Instalado>Visual C++ e selecione Área de trabalho do Windows. No painel do meio, escolha Assistente do Windows Desktop.

    Na caixa Nome, digite um nome para o projeto, por exemplo, DesktopApp. Selecione OK.

    Captura de tela da caixa de diálogo de novo projeto no Visual Studio 2017 com Instalado e Visual C mais mais > Área de trabalho selecionada, a opção de Assistente de área de trabalho do Windows em destaque e DesktopApp digitado na caixa de texto Nome.

  3. Na caixa de diálogo Projeto da Área de Trabalho do Windows, no Tipo de aplicativo, selecione Aplicativo do Windows (.exe). Em Opções adicionais, selecione Projeto vazio. Verifique se o cabeçalho pré-compilado não está selecionado. Clique em OK para criar o projeto.

  4. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto DesktopApp, escolha Adicionar e escolha Novo item.

    Vídeo curto que mostra o usuário adicionando um novo item ao Projeto DesktopApp no Visual Studio 2017.

  5. 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.

    Captura de tela na caixa de diálogo “Adicionar novo item” no Visual Studio 2017 com Instalado e Visual C mais mais selecionado e a opção C mais mais em destaque.

Seu projeto agora está criado e seu arquivo de origem é aberto no editor. Para continuar, pule para Criar o código.

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

  1. No menu Arquivo, escolha Novo e, em seguida, clique em Projeto.

  2. Na caixa de diálogo Novo Projeto, no painel esquerdo, expanda Modelos Instalados>Modelos>Visual C++ e selecione Win32. No painel central, selecione Projeto Win32.

    Na caixa Nome, digite um nome para o projeto, por exemplo, DesktopApp. Selecione OK.

    Captura de tela da caixa de diálogo de novo projeto no Visual Studio 2015 com Instalado > Modelos > Visual C mais mais > Win32 selecionado, a opção de Projeto Win32 em destaque e DesktopApp digitado na caixa de texto Nome.

  3. Na página Visão geral do Assistente de Aplicativo Win32, escolha Avançar.

    Crie o DesktopApp na página Visão Geral do Aplicativo Win32.

  4. Na página Configurações de Aplicativo, em Tipo de aplicativo, escolha Aplicativos do Windows. Em Opções adicionais, desmarque Cabeçalho pré-compilado e selecione Projeto vazio. Escolha Concluir para criar o projeto.

  5. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto DesktopApp, escolha Adicionar e escolha Novo item.

    Vídeo curto que mostra o usuário adicionando um novo item ao Projeto DesktopApp no Visual Studio 2015.

  6. 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.

    Captura de tela na caixa de diálogo “Adicionar novo item” no Visual Studio 2015 com Instalado e Visual C mais mais selecionado e a opção C mais mais em destaque.

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

Criar o código

Em seguida, você aprenderá a criar o código para um aplicativo da área de trabalho do Windows no Visual Studio.

Para iniciar um aplicativo da á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 de SAL para reduzir defeitos de código C/C++.

  2. Os programas da área de trabalho do Windows exigem <windows.h>. <tchar.h> define a macro TCHAR, que se resolve, em última análise para wchar_t, se o símbolo UNICODE for definido em seu projeto, caso contrário, ele se resolverá para char. Se você sempre compilar com UNICODE habilitado, não precisará de TCHAR e pode apenas usar wchar_t diretamente.

    #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. Essa função normalmente é nomeada WndProc, mas você pode nomeá-la como quiser. 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 escolher um botão OK em seu aplicativo, o Windows enviará uma mensagem para você e será possível escrever código dentro da função WndProc que faça qualquer trabalho apropriado. Chamamos isso de tratar de um evento. Você só trata de eventos relevantes para seu aplicativo.

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

Para adicionar funcionalidade à função WinMain

  1. Na função WinMain, você preenche uma estrutura do tipo WNDCLASSEX. A estrutura contém informações sobre a janela: 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. O mais importante: ele contém um ponteiro de função para o procedimento de janela. 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 da estrutura acima, confira WNDCLASSEX.

  2. Registre o WNDCLASSEX com o Windows para que ele saiba sobre sua janela e como enviar mensagens para ela. Use a função RegisterClassEx e passe a estrutura de classe de janela como um argumento. A macro _T é usada porque usamos o tipo TCHAR.

    if (!RegisterClassEx(&wcex))
    {
       MessageBox(NULL,
          _T("Call to RegisterClassEx failed!"),
          _T("Windows Desktop Guided Tour"),
          NULL);
    
       return 1;
    }
    
  3. Agora é possível criar uma janela. Use a função 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;
    }
    

    Essa função retorna um HWND, que é um identificador para uma janela. Um identificador é um pouco como um ponteiro que o Windows usa para controlar janelas abertas. 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 CreateWindow
    // nCmdShow: the fourth parameter from WinMain
    ShowWindow(hWnd,
       nCmdShow);
    UpdateWindow(hWnd);
    

    A janela exibida não tem muito conteúdo porque você ainda não implementou a função WndProc. Em outras palavras, o aplicativo ainda não está tratando as mensagens que o Windows envia a ele.

  5. Para tratar das mensagens, primeiro adicionamos um loop de mensagem para escutar 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 mensagem 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 no loop de mensagem, confira MSG, GetMessage, TranslateMessage e DispatchMessage.

    Neste ponto, a função WinMain deve ser 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, 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 adicionar funcionalidade à função WndProc

  1. Para habilitar a função WndProc para lidar com as mensagens que o aplicativo recebe, implemente uma instrução de troca.

    Uma mensagem importante a ser tratada é a mensagem WM_PAINT. O aplicativo recebe a mensagem WM_PAINT quando parte de sua janela exibida precisa ser atualizada. O evento pode ocorrer quando um usuário move uma janela na frente da janela e, em seguida, a afasta novamente. Seu aplicativo não sabe quando esses eventos ocorrem. Somente o Windows sabe, portanto, ele notifica seu aplicativo com uma mensagem WM_PAINT. Quando a janela é exibida pela primeira vez, tudo isso precisa ser atualizado.

    Para lidar com uma mensagem WM_PAINT, chame primeiro BeginPaint, depois trate de toda a lógica para definir o texto, os botões e outros controles na janela e, em seguida, chame EndPaint. Para o aplicativo, a lógica entre a chamada inicial e a chamada final exibe a cadeia de caracteres "Olá, área de trabalho do Windows!" na janela. No código a seguir, a função TextOut é usada para exibir a cadeia de caracteres.

    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 no código é um identificador para um contexto de dispositivo, usado para desenhar na área de cliente da janela. 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 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 WndProc 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;
    }
    

Compilar o código

Conforme prometido, aqui está o código completo para o aplicativo em funcionamento.

Para criar este exemplo

  1. Exclua qualquer código inserido em 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 <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 Compilar, escolha Compilar Solução. Os resultados da compilação devem aparecer na janela Saída no Visual Studio.

    Animação mostrando as etapas para criar o projeto DesktopApp.

  3. Para executar o aplicativo, pressione F5. Uma janela que contém o texto "Olá, área de trabalho do Windows!" deve aparecer no canto superior esquerdo da exibição.

    Captura de tela do projeto DesktopApp em execução.

Parabéns! Você concluiu este passo a passo e criou um aplicativo de área de trabalho tradicional do Windows.

Confira também

Aplicativo da Área de Trabalho do Windows