Walkthrough: criar um aplicativo de área de trabalhoC++do Windows tradicional ()Walkthrough: Create a traditional Windows Desktop application (C++)

Este tutorial mostra como criar um aplicativo de área de trabalho tradicional do Windows no Visual Studio.This walkthrough shows how to create a traditional Windows desktop application in Visual Studio. O aplicativo de exemplo que você criará usa a API do Windows para exibir "Olá, Windows Desktop!"The example application you'll create uses the Windows API to display "Hello, Windows desktop!" em uma janela.in a window. Você pode usar o código que você desenvolve neste passo a passos como um padrão para criar outros aplicativos da área de trabalho do Windows.You can use the code that you develop in this walkthrough as a pattern to create other Windows desktop applications.

A API do Windows (também conhecida como API do Win32, API de área de trabalho do Windows e Windows API Clássica) é uma estrutura baseada em linguagem C para a criação de aplicativos do Windows.The Windows API (also known as the Win32 API, Windows Desktop API, and Windows Classic API) is a C-language-based framework for creating Windows applications. Ele já existe desde o 80 e foi usado para criar aplicativos do Windows há décadas.It has been in existence since the 1980s and has been used to create Windows applications for decades. Estruturas mais avançadas e mais fáceis de programa foram criadas com base na API do Windows.More advanced and easier-to-program frameworks have been built on top of the Windows API. Por exemplo, MFC, ATL, .NET Frameworks.For example, MFC, ATL, the .NET frameworks. Até mesmo o código Windows Runtime mais moderno para os aplicativos UWP e Store C++escritos em/WinRT usa a API do Windows abaixo.Even the most modern Windows Runtime code for UWP and Store apps written in C++/WinRT uses the Windows API underneath. Para obter mais informações sobre a API do Windows, consulte índice da API do Windows.For more information about the Windows API, see Windows API Index. Há várias maneiras de criar aplicativos do Windows, mas o processo acima foi o primeiro.There are many ways to create Windows applications, but the process above was the first.

Importante

Para fins de brevidade, algumas instruções de código são omitidas no texto.For the sake of brevity, some code statements are omitted in the text. A seção criar o código no final deste documento mostra o código completo.The Build the code section at the end of this document shows the complete code.

PrerequisitesPrerequisites

  • Um computador que executa o Microsoft Windows 7 ou versões posteriores.A computer that runs Microsoft Windows 7 or later versions. Recomendamos o Windows 10 para obter a melhor experiência de desenvolvimento.We recommend Windows 10 for the best development experience.

  • Uma cópia do Visual Studio.A copy of Visual Studio. Para saber mais sobre como fazer o download e instalar o Visual Studio, consulte Instalar o Visual Studio.For information on how to download and install Visual Studio, see Install Visual Studio. Quando executar o instalador, certifique-se de que a carga de trabalho de Desenvolvimento para desktop com C++ esteja marcada.When you run the installer, make sure that the Desktop development with C++ workload is checked. Não se preocupe se não tiver instalado essa carga de trabalho quando instalou o Visual Studio.Don't worry if you didn't install this workload when you installed Visual Studio. Você pode executar o instalador novamente e instalá-la agora.You can run the installer again and install it now.

    Desenvolvimento para desktop com C++Desktop development with C++

  • Um reconhecimento dos princípios básicos do uso do IDE do Visual Studio.An understanding of the basics of using the Visual Studio IDE. Se já tiver usado aplicativos de desktop do Windows, você provavelmente não terá problemas.If you've used Windows desktop apps before, you can probably keep up. Para ver uma introdução, consulte Tour pelos recursos do IDE do Visual Studio.For an introduction, see Visual Studio IDE feature tour.

  • Um reconhecimento dos princípios básicos da linguagem C++ a seguir.An understanding of enough of the fundamentals of the C++ language to follow along. Não se preocupe, não faremos nada muito complicado.Don't worry, we don't do anything too complicated.

Criar um projeto de área de trabalho do WindowsCreate a Windows desktop project

Siga estas etapas para criar seu primeiro projeto de área de trabalho do Windows.Follow these steps to create your first Windows desktop project. Conforme o uso, você inserirá o código para um aplicativo de área de trabalho do Windows em funcionamento.As you go, you'll enter the code for a working Windows desktop application. Há um seletor de versão no canto superior esquerdo desta página.There's a version selector in the upper left of this page. Verifique se ele está definido para a versão do Visual Studio que você está usando.Make sure it's set to the version of Visual Studio that you're using.

Para criar um projeto de área de trabalho do Windows no Visual Studio 2019To create a Windows desktop project in Visual Studio 2019

  1. No menu principal, escolha arquivo > novo projeto de > para abrir a caixa de diálogo criar um novo projeto .From the main menu, choose File > New > Project to open the Create a New Project dialog box.

  2. Na parte superior da caixa de diálogo, defina idioma C++ como, defina plataforma para Windowse defina tipo de projeto como área de trabalho.At the top of the dialog, set Language to C++, set Platform to Windows, and set Project type to Desktop.

  3. Na lista filtrada de tipos de projeto, escolha Assistente de área de trabalho do Windows e escolha Avançar.From the filtered list of project types, choose Windows Desktop Wizard then choose Next. Na próxima página, insira um nome para o projeto, por exemplo, DesktopApp.In the next page, enter a name for the project, for example, DesktopApp.

  4. Escolha o botão Criar para criar o projeto.Choose the Create button to create the project.

  5. A caixa de diálogo projeto de área de trabalho do Windows agora é exibida.The Windows Desktop Project dialog now appears. Em tipo de aplicativo, selecione aplicativo de área de trabalho (. exe) .Under Application type, select Desktop application (.exe). Em Opções adicionais, selecione projeto vazio.Under Additional options, select Empty project. Escolha OK para criar o projeto.Choose OK to create the project.

  6. Em Gerenciador de soluções, clique com o botão direito do mouse no projeto DesktopApp , escolha Adicionare, em seguida, escolha novo item.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Adicionar novo item ao projeto DesktopAppAdd new item to DesktopApp Project

  7. Na caixa de diálogo Adicionar novo item , selecione C++ arquivo (. cpp) .In the Add New Item dialog box, select C++ File (.cpp). Na caixa nome , digite um nome para o arquivo, por exemplo, HelloWindowsDesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Escolha Adicionar.Choose Add.

    Adicionar arquivo. cpp ao projeto DesktopAppAdd .cpp file to DesktopApp Project

Seu projeto agora é criado e o arquivo de origem é aberto no editor.Your project is now created and your source file is opened in the editor. Para continuar, pule para criar o código.To continue, skip ahead to Create the code.

Para criar um projeto de área de trabalho do Windows no Visual Studio 2017To create a Windows desktop project in Visual Studio 2017

  1. No menu Arquivo, escolha Novo e, em seguida, clique em Projeto.On the File menu, choose New and then choose Project.

  2. Na caixa de diálogo novo projeto , no painel esquerdo, expanda instalado > Visual C++ e, em seguida, selecione área de trabalho do Windows.In the New Project dialog box, in the left pane, expand Installed > Visual C++, then select Windows Desktop. No painel central, selecione Assistente de área de trabalho do Windows.In the middle pane, select Windows Desktop Wizard.

    Na caixa nome , digite um nome para o projeto, por exemplo, DesktopApp.In the Name box, type a name for the project, for example, DesktopApp. Escolha OK.Choose OK.

    Nomeie o projeto DesktopAppName the DesktopApp project

  3. Na caixa de diálogo projeto de área de trabalho do Windows , em tipo de aplicativo, selecione aplicativo do Windows (. exe) .In the Windows Desktop Project dialog, under Application type, select Windows application (.exe). Em Opções adicionais, selecione projeto vazio.Under Additional options, select Empty project. Verifique se o cabeçalho pré-compilado não está selecionado.Make sure Precompiled Header isn't selected. Escolha OK para criar o projeto.Choose OK to create the project.

  4. Em Gerenciador de soluções, clique com o botão direito do mouse no projeto DesktopApp , escolha Adicionare, em seguida, escolha novo item.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Adicionar novo item ao projeto DesktopAppAdd new item to DesktopApp Project

  5. Na caixa de diálogo Adicionar novo item , selecione C++ arquivo (. cpp) .In the Add New Item dialog box, select C++ File (.cpp). Na caixa nome , digite um nome para o arquivo, por exemplo, HelloWindowsDesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Escolha Adicionar.Choose Add.

    Adicionar arquivo. cpp ao projeto DesktopAppAdd .cpp file to DesktopApp Project

Seu projeto agora é criado e o arquivo de origem é aberto no editor.Your project is now created and your source file is opened in the editor. Para continuar, pule para criar o código.To continue, skip ahead to Create the code.

Para criar um projeto de área de trabalho do Windows no Visual Studio 2015To create a Windows desktop project in Visual Studio 2015

  1. No menu Arquivo, escolha Novo e, em seguida, clique em Projeto.On the File menu, choose New and then choose Project.

  2. Na caixa de diálogo novo projeto , no painel esquerdo, expanda instalado > modelos > Visual C++ e, em seguida, selecione Win32.In the New Project dialog box, in the left pane, expand Installed > Templates > Visual C++, and then select Win32. No painel central, selecione projeto Win32.In the middle pane, select Win32 Project.

    Na caixa nome , digite um nome para o projeto, por exemplo, DesktopApp.In the Name box, type a name for the project, for example, DesktopApp. Escolha OK.Choose OK.

    Nomeie o projeto DesktopAppName the DesktopApp project

  3. Na página visão geral do Assistente de aplicativo Win32, escolha Avançar.On the Overview page of the Win32 Application Wizard, choose Next.

    Visão geral do assistente para criar DesktopApp no aplicativo Win32Create DesktopApp in Win32 Application Wizard Overview

  4. Na página configurações do aplicativo , em tipo de aplicativo, selecione aplicativo do Windows.On the Application Settings page, under Application type, select Windows application. Em Opções adicionais, desmarque cabeçalho pré-compiladoe, em seguida, selecione projeto vazio.Under Additional options, uncheck Precompiled header, then select Empty project. Escolha concluir para criar o projeto.Choose Finish to create the project.

  5. Em Gerenciador de soluções, clique com o botão direito do mouse no projeto DesktopApp, escolha Adicionare, em seguida, escolha novo item.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Adicionar novo item ao projeto DesktopAppAdd new item to DesktopApp Project

  6. Na caixa de diálogo Adicionar novo item , selecione C++ arquivo (. cpp) .In the Add New Item dialog box, select C++ File (.cpp). Na caixa nome , digite um nome para o arquivo, por exemplo, HelloWindowsDesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Escolha Adicionar.Choose Add.

    Adicionar arquivo. cpp ao projeto DesktopAppAdd .cpp file to DesktopApp Project

Seu projeto agora é criado e o arquivo de origem é aberto no editor.Your project is now created and your source file is opened in the editor.

Criar o códigoCreate the code

Em seguida, você aprenderá a criar o código para um aplicativo de área de trabalho do Windows no Visual Studio.Next, you'll learn how to create the code for a Windows desktop application in Visual Studio.

Para iniciar um aplicativo da área de trabalho do WindowsTo start a Windows desktop application

  1. Assim como todos os aplicativos e C++ aplicativos C devem ter uma função main como ponto de partida, todos os aplicativos da área de trabalho do Windows devem ter uma função WinMain.Just as every C application and C++ application must have a main function as its starting point, every Windows desktop application must have a WinMain function. WinMain tem a sintaxe a seguir.WinMain has the following syntax.

    int CALLBACK 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.For information about the parameters and return value of this function, see WinMain entry point.

    Observação

    Quais são as palavras adicionais, como CALLBACK, ou HINSTANCEou _In_?What are all those extra words, such as CALLBACK, or HINSTANCE, or _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 de __declspec e pragmas do compilador.The traditional Windows API uses typedefs and preprocessor macros extensively to abstract away some of the details of types and platform-specific code, such as calling conventions, __declspec declarations, and compiler pragmas. No Visual Studio, você pode usar o recurso de informações rápidas do IntelliSense para ver o que esses TYPEDEFs e macros definem.In Visual Studio, you can use the IntelliSense Quick Info feature to see what these typedefs and macros define. Passe o mouse sobre a palavra de interesse ou selecione-o e pressione ctrl+K, Ctrl+I para uma pequena janela pop-up que contém a definição.Hover your mouse over the word of interest, or select it and press Ctrl+K, Ctrl+I for a small pop-up window that contains the definition. Para obter mais informações, veja Usando o IntelliSense.For more information, see Using IntelliSense. Os parâmetros e os tipos de retorno geralmente usam anotações sal para ajudá-lo a detectar erros de programação.Parameters and return types often use SAL Annotations to help you catch programming errors. Para obter mais informações, consulte usando anotações de sal para reduzir osC++ defeitos de C/código.For more information, see Using SAL Annotations to Reduce C/C++ Code Defects.

  2. Os programas da área de trabalho do Windows exigem <> Windows. h.Windows desktop programs require <windows.h>. <TCHAR. h > define a macro TCHAR, que é resolvida por fim para wchar_t se o símbolo Unicode é definido em seu projeto, caso contrário, ele é resolvido para Char.<tchar.h> defines the TCHAR macro, which resolves ultimately to wchar_t if the UNICODE symbol is defined in your project, otherwise it resolves to char. Se você sempre criar com UNICODE habilitado, não precisará de TCHAR e poderá usar apenas wchar_t diretamente.If you always build with UNICODE enabled, you don't need TCHAR and can just use wchar_t directly.

    #include <windows.h>
    #include <tchar.h>
    
  3. Junto com a função WinMain, todos os aplicativos da área de trabalho do Windows também devem ter uma função de procedimento de janela.Along with the WinMain function, every Windows desktop application must also have a window-procedure function. Essa função normalmente é chamada de WndProc, mas você pode nomeá-la como desejar.This function is typically named WndProc, but you can name it whatever you like. WndProc tem a sintaxe a seguir.WndProc has the following syntax.

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

    Nessa função, você escreve o código para tratar as mensagens que o aplicativo recebe do Windows quando ocorrem eventos .In this function, you write code to handle messages that the application receives from Windows when events occur. Por exemplo, se um usuário escolher um botão OK em seu aplicativo, o Windows enviará uma mensagem para você e você poderá escrever código dentro de sua função WndProc que faça qualquer trabalho apropriado.For example, if a user chooses an OK button in your application, Windows will send a message to you and you can write code inside your WndProc function that does whatever work is appropriate. Ele é chamado de tratamento de um evento.It's called handling an event. Você só lida com os eventos que são relevantes para seu aplicativo.You only handle the events that are relevant for your application.

    Para obter mais informações, consulte procedimentos de janela.For more information, see Window Procedures.

Para adicionar funcionalidade à função WinMainTo add functionality to the WinMain function

  1. Na função WinMain, você preenche uma estrutura do tipo WNDCLASSEX.In the WinMain function, you populate a structure of type 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.The structure contains information about the window: the application icon, the background color of the window, the name to display in the title bar, among other things. É importante que ele contenha um ponteiro de função para o procedimento de janela.Importantly, it contains a function pointer to your window procedure. O exemplo a seguir mostra uma estrutura de WNDCLASSEX típica.The following example shows a typical WNDCLASSEX structure.

    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(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, consulte WNDCLASSEX.For information about the fields of the structure above, see WNDCLASSEX.

  2. Registre o WNDCLASSEX com o Windows para que ele saiba sobre sua janela e como enviar mensagens para ela.Register the WNDCLASSEX with Windows so that it knows about your window and how to send messages to it. Use a função RegisterClassEx e passe a estrutura da classe Window como um argumento.Use the RegisterClassEx function and pass the window class structure as an argument. A macro _T é usada porque usamos o tipo TCHAR.The _T macro is used because we use the TCHAR type.

    if (!RegisterClassEx(&wcex))
    {
       MessageBox(NULL,
          _T("Call to RegisterClassEx failed!"),
          _T("Windows Desktop Guided Tour"),
          NULL);
    
       return 1;
    }
    
  3. Agora você pode criar uma janela.Now you can create a window. Use a função CreateWindow .Use the CreateWindow function.

    static TCHAR szWindowClass[] = _T("DesktopApp");
    static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
    
    // The parameters to CreateWindow explained:
    // 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 = CreateWindow(
       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;
    }
    

    Essa função retorna um HWND, que é um identificador para uma janela.This function returns an HWND, which is a handle to a window. Um identificador é, de certa forma, semelhante a um ponteiro que o Windows usa para manter o controle das janelas abertas.A handle is somewhat like a pointer that Windows uses to keep track of open windows. Para obter mais informações, consulte tipos de dados do Windows.For more information, see Windows Data Types.

  4. Neste ponto, a janela foi criada, mas ainda precisamos dizer ao Windows para torná-la visível.At this point, the window has been created, but we still need to tell Windows to make it visible. Isso é o que esse código faz:That's what this code does:

    // 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.The displayed window doesn't have much content because you haven't yet implemented the WndProc function. Em outras palavras, o aplicativo ainda não está manipulando as mensagens que o Windows está enviando agora para ele.In other words, the application isn't yet handling the messages that Windows is now sending to it.

  5. Para lidar com as mensagens, primeiro adicionamos um loop de mensagem para escutar as mensagens que o Windows envia.To handle the messages, we first add a message loop to listen for the messages that Windows sends. Quando o aplicativo recebe uma mensagem, esse loop a distribui para a função WndProc a ser manipulada.When the application receives a message, this loop dispatches it to your WndProc function to be handled. O loop de mensagem é semelhante ao código a seguir.The message loop resembles the following code.

    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, consulte msg, GetMessage, TranslateMessagee DispatchMessage.For more information about the structures and functions in the message loop, see MSG, GetMessage, TranslateMessage, and DispatchMessage.

    Neste ponto, a função WinMain deve ser semelhante ao código a seguir.At this point, the WinMain function should resemble the following code.

    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(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 CreateWindow explained:
       // 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 = CreateWindow(
          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 WndProcTo add functionality to the WndProc function

  1. Para habilitar a função WndProc para manipular as mensagens que o aplicativo recebe, implemente uma instrução switch.To enable the WndProc function to handle the messages that the application receives, implement a switch statement.

    Uma mensagem importante a ser tratada é a WM_PAINT mensagem.One important message to handle is the WM_PAINT message. O aplicativo recebe a WM_PAINT mensagem quando parte de sua janela exibida deve ser atualizada.The application receives the WM_PAINT message when part of its displayed window must be updated. O evento pode ocorrer quando um usuário move uma janela na frente da janela e, em seguida, move-a para fora novamente.The event can occur when a user moves a window in front of your window, then moves it away again. Seu aplicativo não sabe quando esses eventos ocorrem.Your application doesn't know when these events occur. Somente o Windows sabe, portanto, ele notifica seu aplicativo com uma mensagem WM_PAINT.Only Windows knows, so it notifies your app with a WM_PAINT message. Quando a janela é exibida pela primeira vez, todas elas devem ser atualizadas.When the window is first displayed, all of it must be updated.

    Para manipular uma mensagem de WM_PAINT, primeiro chame BeginPainte, em seguida, manipule toda a lógica para dispor o texto, os botões e outros controles na janela e, em seguida, chame EndPaint.To handle a WM_PAINT message, first call BeginPaint, then handle all the logic to lay out the text, buttons, and other controls in the window, and then call EndPaint. Para o aplicativo, a lógica entre a chamada inicial e a chamada final é exibir a cadeia de caracteres "Olá, Windows Desktop!"For the application, the logic between the beginning call and the ending call is to display the string "Hello, Windows desktop!" na janela.in the window. No código a seguir, observe que a função TextOut é usada para exibir a cadeia de caracteres.In the following code, notice that the TextOut function is used to display the string.

    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, que é uma estrutura de dados que o Windows usa para permitir que seu aplicativo se comunique com o subsistema de gráficos.HDC in the code is a handle to a device context, which is a data structure that Windows uses to enable your application to communicate with the graphics subsystem. As funções BeginPaint e EndPaint fazem com que seu aplicativo se comporte como um bom cidadão e não use o contexto do dispositivo por mais tempo do que o necessário.The BeginPaint and EndPaint functions make your application behave like a good citizen and doesn't use the device context for longer than it needs to. As funções ajudam a tornar o subsistema de gráficos disponível para uso por outros aplicativos.The functions help make the graphics subsystem is available for use by other applications.

  2. Um aplicativo normalmente lida com muitas outras mensagens.An application typically handles many other messages. Por exemplo, WM_CREATE quando uma janela é criada pela primeira vez e WM_DESTROY quando a janela é fechada.For example, WM_CREATE when a window is first created, and WM_DESTROY when the window is closed. O código a seguir mostra uma função de WndProc básica, mas completa.The following code shows a basic but complete WndProc function.

    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ódigoBuild the code

Como prometido, aqui está o código completo do aplicativo de trabalho.As promised, here's the complete code for the working application.

Para criar este exemploTo build this example

  1. Exclua qualquer código que você tenha inserido em HelloWindowsDesktop. cpp no editor.Delete any code you've entered in HelloWindowsDesktop.cpp in the editor. Copie este código de exemplo e cole-o em HelloWindowsDesktop. cpp:Copy this example code and then paste it into 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");
    
    HINSTANCE hInst;
    
    // Forward declarations of functions included in this code module:
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    
    int CALLBACK 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(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 CreateWindow explained:
       // 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 = CreateWindow(
          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.On the Build menu, choose Build Solution. Os resultados da compilação devem aparecer na janela de saída no Visual Studio.The results of the compilation should appear in the Output window in Visual Studio.

    Compilar o projeto DesktopAppBuild the DesktopApp Project

  3. Para executar o aplicativo, pressione F5.To run the application, press F5. Uma janela que contém o texto "Olá, Windows Desktop!"A window that contains the text "Hello, Windows desktop!" deve aparecer no canto superior esquerdo da tela.should appear in the upper-left corner of the display.

    Executar o projeto DesktopAppRun the DesktopApp Project

Parabéns!Congratulations! Você concluiu este passo a passo e criou um aplicativo de área de trabalho tradicional do Windows.You've completed this walkthrough and built a traditional Windows desktop application.

Confira tambémSee also

Aplicativos da área de trabalho do WindowsWindows Desktop Applications