Partilhar via

Criando aplicativos Win32 (C++)

  • Artigo

A API do Win32 (também conhecido sistema autônomo API do Windows) é uma estrutura baseada em C para a criação de aplicativos do Windows e desde o Windows 1.0.Documentação abrangente para essa API pode ser encontrada em API do Windows.

Neste procedimento, nós criar um aplicativo Win32 simples que exibe "Hello, World!" para uma janela.As etapas do procedimento são idênticas para todos os aplicativos Win32.Depois de concluir este procedimento, você pode usar o código que você criou aqui sistema autônomo um esqueleto para criar qualquer Outros aplicativo Win32.

Pré-requisitos

Este tópico pressupõe que você entenda os fundamentos da linguagem C++.Se apenas começar aprendendo C++, recomendamos que o "Guia de C++ iniciantes", escrito por Herb Schildt, disponível online emhttps://go.Microsoft.com/fwlink/?LinkId=115303.

Para uma demonstração de vídeo, consulte Vídeo How to: Criando aplicativos Win32 (C++).

Para criar um novo projeto Win32

  1. Sobre o Arquivo menu, clicar Novoe, em seguida, clicar Projeto... .

  2. No Tipos de projeto painel, selecionar Win32 in the O Visual C++ nó e, em seguida, selecionar Projeto Win32 in the Modelos painel.

    Digite um nome para o projeto such sistema autônomo Win32app.Você pode aceitar o localização padrão, digite um local ou navegue para um diretório onde você deseja salvar o projeto.

  3. Sobre o Win32 aplicativo Assistente, selecionar Próximo.

  4. Sobre o Assistente de aplicativos Win32, under Tipo de aplicativo selecionar aplicativos do Windows.Em Opções adicionais selecionar Projeto vazio.Deixe sistema autônomo opções restantes sistema autônomo estão.clicar Concluir para criar o projeto.

  5. Adicione um arquivo C++ para o projeto selecionando Adicione novo item... from the Projeto menu.No Adicionar novo item caixa de diálogo de de seleçãoArquivo do C++ (CPP).Digite um nome para o arquivo, sistema autônomo GT_HelloWorldWin32.cppe clicar Adicionar.

Para iniciar aplicativos do Win32

  1. sistema autônomo você sabe, todos sistema autônomo aplicativos C e C++ devem ter um main função. Essa função é o ponto de partida para o aplicativo.Da mesma forma, em um aplicativo Win32, cada aplicativo deve ter um WinMain função. A sintaxe de WinMain é sistema autônomo segue:

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

    Para obter uma explicação sobre os parâmetros e o valor retornado dessa função, consulte Função WinMain.

  2. Em adição a WinMain, cada aplicativo Win32 também deve ter uma segunda função que normalmente é chamada WndProc, que significa de procedimento de janela. A sintaxe de WndProc é sistema autônomo segue:

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

    A finalidade desta função é tratar qualquer mensagens que seu aplicativo recebe do sistema operacional.Quando o aplicativo receber mensagens do sistema operacional?O time todo!Por exemplo, imagine que criamos uma caixa de diálogo que possui um OK botão.Quando o usuário clica nesse botão, o sistema operacional envia nosso aplicativo de uma mensagem, o que nos permite saber que um usuário pressionado este botão.The WndProc função é responsável por responder a esse evento. Em nosso exemplo, a resposta apropriada pode ser fechar a caixa de diálogo.

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

Para adicionar funcionalidade a WinMain

  1. Primeiro, crie dentro de WinMain uma estrutura de classe de janela do tipo de função WNDCLASSEX.Essa estrutura contém informações sobre a janela, sistema autônomo o ícone do aplicativo, a cor do plano de fundo da janela, o nome para exibir o BAR de título, o nome da função de procedimento de janela e assim por diante.Um típico WNDCLASSEX estrutura a seguir:

        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 uma explicação dos campos dessa estrutura, consulte WNDCLASSEX.

  2. Agora que você criou sua classe de janela, você deve registrá-lo.Use o RegisterClassEx função e passar a estrutura de classe de janela sistema autônomo um argumento:

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

        return 1;
    }

  3. Agora que você registrou sua classe, é time de criar uma janela.Use o CreateWindow funcionam da seguinte maneira:

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

    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 que temos criou a janela, podemos exibi-lo para a tela usando o código a seguir:

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

    Até agora, essa janela não exibirá muito, porque nós ainda não implementaram o WndProc função.

  5. A etapa final do WinMain é o loop de mensagem. A finalidade desse loop é escutar as mensagens que envia o sistema operacional.Quando o aplicativo recebe uma mensagem, a mensagem será enviada para o WndProc função para lidar com ele. O loop de mensagem se parece com isso:

        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 que são usadas no loop de mensagem, consulte MSG, GetMessage, TranslateMessage, and DispatchMessage.

  6. As etapas que você já concluiu são comuns à maioria dos aplicativos do Win32.Neste ponto, seu WinMain função deverá ser semelhante a esta:

    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 a WndProc

  1. O objetivo de WndProc função é tratar mensagens que recebe o aplicativo. Isso geralmente implementado usando uma função de comutador.

    A primeira mensagem irá lidar com é o WM_PAINT mensagem.Seu aplicativo recebe esta mensagem quando uma parte da janela do aplicativo deve ser atualizada.Quando uma janela é criada pela primeira vez, toda a janela deve ser atualizada e esta mensagem é passada para indicar isso.

    A primeira coisa que você deve fazer quando você manipula um WM_PAINT mensagem é telefonar BeginPainte a última coisa que você deve fazer é telefonar EndPaint.Entre essas chamadas de dois função você manipular toda a lógica para dispor o texto, botões e outros controles para a sua janela.Para este aplicativo, exibe a seqüência de caracteres "Hello, World!" dentro da janela.Para exibir texto, use o TextOut função, sistema autônomo mostrado aqui:

    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. Seu aplicativo manipulará normalmente muitas outras mensagens, por exemplo, WM_CREATE and WM_DESTROY.Um simples mas completo WndProc função a seguir:

    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

Descrição

Após todas as etapas, seu código deve ser semelhante ao seguinte.Para criar o aplicativo, selecionar Criar solução from the Compilação menu.Se seu aplicativo é compilado sem erros, você pode executar o aplicativo pressionando F5.Uma janela simples com o texto "Hello, World!" será exibida na tela próximo ao canto superior esquerdo.

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

//
//  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:Criando aplicativos Windows (C++) | Próxima:Criando um aplicativo de formulários do Windows usando o .NET estrutura (C++)

Consulte também

Tarefas

Criando aplicativos Windows (C++)