Compartilhar via

Creating Win32 Applications (C++)

  • Artigo

Essa explicação passo a passo mostra como criar um aplicativo básico de Win32-based que exibe “hello, world!” em uma janela.Você pode usar o código que você desenvolve nessa explicação passo a passo como um padrão para criar outros aplicativos de Win32-based.

A API do Win32 (também conhecido como o Windows API) é baseado em estrutura de energia AC para criar aplicativos do Windows.Para obter mais informações sobre a API do Win32, consulte Windows API.

Observação importanteImportante

De modo que nós pudéssemos mais claramente explicar segmentos específicos das etapas neste documento, nós pudemos omitir algumas declarações de código que são necessárias de outra maneira para um aplicativo trabalhando; por exemplo, incluir diretivas e declarações de variável global.A seção de Exemplo no final deste documento mostra o código completo.

Pré-requisitos

Para concluir esta explicação passo-a-passo, você deve entender os conceitos básicos da linguagem C++.

Para uma demonstração de vídeo, consulte Como: exibição Criando aplicativos Win32 (C++) a documentação do Visual Studio 2008.

Para criar um projeto de Win32-based

  1. No menu de Arquivo , clique em Novo e clique em Projeto.

  2. Na caixa de diálogo de Novo Projeto , no painel esquerdo, clique em Modelos Instalados, clique em Visual C++, e selecione Win32.No painel do meio, selecione Projeto Win32.

    Na caixa de Nome , digite um nome para o projeto, por exemplo, win32app.Clique em OK.

  3. Na página bem-vindo de Assistente de aplicação Win32, clique em Avançar.

  4. Na página de configurações do aplicativo, em Tipo de Aplicativo, Aplicativo do Windowsselecione.Em Opções Adicionais, selecione Projeto Vazio.Clique Concluir para criar o projeto.

  5. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto de Win32app, clique Adicionar, clique em Novo Item.Na caixa de diálogo de Adicionar novo item , selecione Arquivo do C++ (.cpp).Na caixa de Nome , digite um nome para o arquivo, por exemplo, GT_HelloWorldWin32.cpp.Clique em Adicionar.

Para iniciar um aplicativo de Win32-based

  1. Da mesma forma que cada aplicativo de C e o aplicativo C++ devem ter uma função de main como o ponto inicial, cada aplicativo de Win32-based deve ter uma função de WinMain .WinMain possui a seguinte sintaxe.

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

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

  2. Porque o código do aplicativo deve usar existentes, adicione definições incluem instruções para o arquivo.

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

  3. Além da função de WinMain , cada aplicativo de Win32-based também deve ter uma função de procedimento de janela.Essa função é chamada normalmente WndProc.WndProc possui a seguinte sintaxe.

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

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

    Para obter mais informações, consulte Procedimentos da janela.

Para adicionar funcionalidade à função de WinMain

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

        WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(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 campos dessa estrutura, consulte WNDCLASSEX.

  2. Agora que você criou uma classe de janela, você deve registrá-lo.Use a função de RegisterClassEx 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 a função de CreateWindow .

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

    Essa 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 código a seguir 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 você ainda não tiver implementado a função de WndProc .

  5. Agora adicione um loop de mensagem para escutar as mensagens que envia o sistema operacional.Quando o aplicativo, receber uma mensagem expedições deste loop ele à função de WndProc a ser tratada.O loop de mensagem é semelhante ao seguinte código.

        MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int) msg.wParam;

    Para obter mais informações sobre as estruturas e funções mensagem em um loop, consulte em MSG, em GetMessage, em TranslateMessage, e em DispatchMessage.

    Neste ponto, a função de WinMain deve se parecer com o seguinte código.

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

    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(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 à função de WndProc

  1. Para ativar WndProc funciona para manipular as mensagens que o aplicativo recebe, implementam uma declaração de opção.

    A primeira mensagem a tratar é a mensagem de WM_PAINT .O aplicativo recebe esta mensagem quando a parte de sua janela exibida deve ser atualizada.(Quando a janela é exibida primeiro, qualquer ele deve ser atualizada.)

    Para manipular uma mensagem de WM_PAINT , um primeira chamada BeginPaint, manipular em toda a lógica para formatar o texto, botões, e outros controles na janela, e então chame EndPaint.Para este aplicativo, a lógica entre a chamada a chamada de início e final é exibir a cadeia de caracteres “hello, world!” na janela.No código a seguir, observe que a função de TextOut é usada para exibir a cadeia 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 trata muitas outras mensagens, por exemplo, WM_CREATE e WM_DESTROY.O código a seguir mostra uma função básica mas completo de WndProc .

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

Exemplo

Para criar esse exemplo

  1. Crie um projeto de Win32-based conforme mostrado em “criar um projeto de Win32-based” anteriormente neste passo-a-passo.

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

  3. No menu Build, 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 exibição.

Bb384843.collapse_all(pt-br,VS.110).gifCódigo

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

Consulte também

Tarefas

Win32 Windows Applications (C++)