Criação de aplicativos baseados no Win32 (C++)

  • Artigo

Esta explicação passo a passo mostra como criar um aplicativo básico baseados em Win32 que exibe "Hello, World!" em uma janela. Você pode usar o código que você desenvolva esta explicação passo a passo como um padrão para criar outros aplicativos baseados no Win32.

A API do Win32 (também conhecido como API do Windows) é uma estrutura baseada em c para criar aplicativos do Windows. Para obter mais informações sobre a API do Win32, consulte API do Windows.

Observação importanteImportante

Para que conseguimos explicar mais claramente determinados segmentos de código nas etapas neste documento, podemos pode omitir algumas instruções de código que seriam necessários para um aplicativo de trabalho; Por exemplo, inclua diretivas e as declarações de variáveis globais. O exemplo seção no final deste documento mostra o código completo.

Pré-requisitos

To complete this walkthrough, you must understand the fundamentals of the C++ language. Se você apenas estiver começando a aprender C++, recomendamos que o "guia para iniciantes do C++" por Herb Schildt, que está disponível no Central de desenvolvedores iniciantes no site do MSDN.

Para uma demonstração em vídeo, consulte vídeo How to: A criação de aplicativos do Win32 (C++) na documentação do Visual Studio de 2008.

Para criar um projeto baseado no Win32

  1. Sobre o arquivo menu, clique em novo e, em seguida, clique em projeto.

  2. No Novo projeto caixa de diálogo, no painel esquerdo, clique em Modelos instalados, clique em **Visual C++**e selecione Win32. No painel central, selecione Projeto Win32.

    No nome , digite um nome para o projeto, por exemplo, win32app. Click OK.

  3. Na página de boas-vindas a Assistente de aplicativo Win32, clique em próximo.

  4. Na página Configurações do aplicativo, em o tipo de aplicativo, selecione Windows application. Em Opções adicionais de, selecione projeto vazio. Clique em Concluir para criar o projeto.

  5. Em Solution Explorer, o botão direito do mouse no projeto Win32app, clique em Adde em seguida, clique em Novo Item. No Add New Item caixa de diálogo, selecione Arquivo do C++ (CPP). No nome , digite um nome para o arquivo, por exemplo, GT_HelloWorldWin32.cpp. Click Add.

Para iniciar um aplicativo baseado no Win32

  1. Assim como cada c e C++ aplicativo devem ter um main função como seu ponto de partida, todos os aplicativos baseados no Win32 deve ter um WinMain função. WinMaintem a seguinte sintaxe.

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

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

  2. Como o código do aplicativo deve usar as definições existentes, adicionar incluir instruções para o arquivo.

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

  3. Além de WinMain função, todos os aplicativos baseados no Win32 também devem ter uma função do procedimento de janela. Esta função é normalmente denominada WndProc. WndProctem a seguinte sintaxe.

    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

    Essa função manipula muitas mensagens que recebe de um aplicativo do sistema operacional. Por exemplo, em um aplicativo que tenha uma caixa de diálogo que tem um OK o botão, quando o usuário clica no botão, o sistema operacional envia o aplicativo uma mensagem que o botão foi clicado. WndProcé responsável por responder ao evento. No exemplo, pode ser a resposta apropriada fechar a caixa de diálogo.

    Para obter mais informações, consulte Os procedimentos de janela.

Para adicionar funcionalidade para a função WinMain

  1. No WinMain function, criar uma estrutura de classe de janela do tipo WNDCLASSEX. Esta estrutura contém informações sobre a janela, por exemplo, o ícone do aplicativo, a cor de plano de fundo da janela, o nome exibido na barra de título, o nome da função do procedimento de janela, e assim por diante. O exemplo a seguir mostra uma típica WNDCLASSEX estrutura.

        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, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));

    Para obter informações sobre os campos dessa estrutura, consulte WNDCLASSEX.

  2. Agora que você criou uma classe de janela, você deve registrá-lo. Use o RegisterClassEx de função e passe a estrutura de classe de janela como um argumento.

        if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            NULL);

        return 1;
    }

  3. Agora você pode criar uma janela. Use o CreateWindow função.

    static TCHAR szWindowClass[] = _T("win32app");
static TCHAR szTitle[] = _T("Win32 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("Win32 Guided Tour"),
        NULL);

    return 1;
}

    Esta função retorna um HWND, que é um identificador para uma janela. Para obter mais informações, consulte Tipos de dados do Windows.

  4. Agora, use o seguinte código para exibir a janela.

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

    Neste ponto, a janela exibida não terá muito conteúdo porque ainda não foi implementado o WndProc função.

  5. Agora, adicione um loop de mensagem para ouvir as mensagens que o sistema operacional envia. Quando o aplicativo recebe uma mensagem, este loop despacha-lo para o WndProc a função deve ser tratado. 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, consulte MSG, GetMessage, TranslateMessage, e DispatchMessage.

    Neste ponto, o WinMain função deverá ser semelhante o 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(hInstance, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));

    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            NULL);

        return 1;
    }

    hInst = hInstance; // Store instance handle in our global variable

    // 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("Win32 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 para a função WndProc

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

    É a primeira mensagem para lidar com o WM_PAINT mensagem. O aplicativo recebe essa mensagem quando a parte de sua janela exibida deve ser atualizado. (Quando a janela é exibida pela primeira vez, tudo isso deve ser atualizado.)

    Para lidar com um WM_PAINT mensagem, a primeira chamada BeginPaint, em seguida, manipule toda a lógica para dispor o texto, botões e outros controles na janela e, em seguida, chamar EndPaint. Para este aplicativo, a lógica entre a chamada de início e a chamada final é exibir a seqüência de caracteres "Hello, World!" na janela. No código a seguir, observe que o TextOut função é usada para exibir a seqüência de caracteres.

    PAINTSTRUCT ps;
HDC hdc;
TCHAR greeting[] = _T("Hello, World!");

switch (message)
{
case WM_PAINT:
    hdc = BeginPaint(hWnd, &ps);

    // Here your application is laid out.
    // For this introduction, we just print out "Hello, World!"
    // in the top left corner.
    TextOut(hdc,
        5, 5,
        greeting, _tcslen(greeting));
    // End application-specific layout section.

    EndPaint(hWnd, &ps);
    break;
}

  2. Um aplicativo normalmente manipula muitas mensagens, por exemplo, WM_CREATE e WM_DESTROY. O código a seguir mostra um basic mas concluir WndProc função.

    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    TCHAR greeting[] = _T("Hello, World!");

    switch (message)
    {
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);

        // Here your application is laid out.
        // For this introduction, we just print out "Hello, World!"
        // 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;
}

Example

Para criar esse exemplo.

  1. Criar um projeto baseado em Win32, como mostrado em "Para criar um projeto baseado em Win32" anteriormente neste passo a passo.

  2. Copie o código que segue estas etapas e cole-o no arquivo de origem GT_HelloWorldWin32.cpp.

  3. Sobre o Build menu, clique em Build Solution.

  4. Para executar o aplicativo, pressione F5. Uma janela que contém o texto "Hello World!". deve aparecer no canto superior esquerdo da tela.

Code

// GT_HelloWorldWin32.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("win32app");

// The string that appears in the application's title bar.
static TCHAR szTitle[] = _T("Win32 Guided Tour Application");

HINSTANCE hInst;

// Forward declarations of functions included in this code module:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

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, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));

    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            NULL);

        return 1;
    }

    hInst = hInstance; // Store instance handle in our global variable

    // 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("Win32 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, World!");

    switch (message)
    {
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);

        // Here your application is laid out.
        // For this introduction, we just print out "Hello, World!"
        // 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;
}

Próximas etapas

Anterior: Criação de aplicativos do Windows (C++) | Próxima: A criação de um aplicativo do Windows Forms usando o.NET Framework (C++)

Consulte também

Tarefas

Criação de aplicativos do Windows (C++)

Histórico de alterações

Date

History

Motivo

Dezembro de 2010

Indicado que talvez omitimos alguns caso contrário, é necessário instruções de código para que mais claramente explicamos outras partes do código.

Comentários do cliente.