Aracılığıyla paylaş

Win 32 tabanlı uygulamalarda (c++) oluşturma

  • Makale

Bu gidiş yolu bir pencerede "Hello World!" görüntüleyen temel bir Win32 tabanlı uygulama oluşturmayı gösterir.Bu izlenecek yolda geliştirdiğiniz kodu diğer Win32 tabanlı uygulamalar oluşturmak için model olarak kullanabilirsiniz.

Win32 API (Windows API olarak da bilinir) Windows uygulamaları oluşturmak için C tabanlı frameworktür.Win32 API hakkında daha fazla bilgi için bkz. Windows API.

Önemli notÖnemli

Bu belgedeki adımları kodda belirli parçalarını daha net açıklayabiliriz böylece aksi takdirde çalışan bir uygulama için gerekli bazı kod deyimlerini yoksayabiliriz; Örneğin, yönergeleri ve genel değişken bildirimleri içerir.Bu belgenin sonundaki Örnek bölümünde tam kod gösterilir.

Önkoşullar

Bu gidiş yolunu tamamlamak için C++ dilinin temellerini anlamanız gerekir.

Video gösterimi için bkz. Video Nasıl: Win32 Uygulamaları Oluşturma (C++) Visual Studio 2008 belgelerinde.

Win32 tabanlı bir proje oluşturmak için

  1. Dosya menüsünde, Yeni'yi ve sonra da Proje'yi tıklatın.

  2. Yeni Proje iletişim kutusunda, sol bölmede, Yüklü Şablonlar,'ı tıklayın, Visual C++ öğesini tıklayın ve sonra şunu seçin: Win32.Orta bölmede şunu seçin: Win32 Proje.

    Ad kutusu içine proje için bir ad yazın örneğin, win32app.Tamam düğmesini tıklatın.

  3. Win32 Uygulama Sihirbazı'nın Hoş Geldiniz sayfasında şunu tıklayın Sonraki.

  4. Uygulama Ayarları sayfası üzerinde, Uygulama türü altında, Windows uygulaması öğesini seçin.Ek seçenekler altında, şunu seçin: Boş proje.Proje oluşturmak için Son öğesini tıklayın.

  5. Çözüm Gezgini içinde Win32app projesini sağ tıklayın, Ekle'yi tıklayın ve ardından Yeni Öğe'yi tıklayın.Yeni Öğe Ekle iletişim kutusunda, C++ File (.cpp) seçin.Ad kutusuna dosya için bir ad yazın örneğin, GT_HelloWorldWin32.cpp.Ekle‘yi tıklatın.

Win32 tabanlı bir uygulamayı başlatmak için

  1. Tıpkı her C uygulaması ve C++ uygulamasının başlangıç noktası için bir main fonksiyonu olması gibi her Win32 tabanlı uygulama da bir WinMain fonksiyonuna sahip olmalıdır.WinMain aşağıdaki sözdizimine sahiptir.

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

    Bu fonksiyonun dönüş değeri ve parametreleri hakkında daha fazla bilgi için bkz. WinMain Fonksiyonu.

  2. Uygulama kodunun varolan tanımları kullanması gerektiğinden, içerik ifadeleri dosyaya ekleyin.

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

  3. Ek olarak WinMain fonksiyonu her Win32 tabanlı bir uygulama bir pencere-yordamı fonksiyonuna sahip olmalıdır.Bu fonksiyon genellikle şöyle adlandırılır WndProc.WndProc aşağıdaki sözdizimine sahiptir.

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

    Bu fonksiyon bir uygulamanın işletim sisteminden aldığı birçok iletileri yakalar.Örneğin, bir Tamam düğmesi olan bir iletişim kutusuna sahip bir uygulamada, kullanıcı düğmeyi tıklattığında işletim sistemi uygulamaya düğme tıklatıldı ileti gönderir.WndProc öğesi o olay için yanıtlamadan sorumludur.Örnekte, uygun yanıt iletişim kutusunu kapatmak için olabilir.

    Daha fazla bilgi için bkz. Pencere Prosedürleri.

WinMain fonksiyonuna işlevsellik eklemek için

  1. WinMain fonksiyonu içine WNDCLASSEX türünün bir pencere sınıf yapısı oluşturun.Bu yapı pencere hakkında bilgiler içerir, örneğin, uygulama simgesi, pencerenin arka plan rengi, başlık çubuğunda gösterilecek ad, pencere yordamı fonksiyonunun adı vb.Aşağıdaki örnek genel bir WNDCLASSEX yapısı göstermektedir.

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

    Bu yapının alanları hakkında daha fazla bilgi için bkz. WNDCLASSEX.

  2. Şimdi pencere sınıfı oluşturduysanız, onu kaydetmeniz gerekir.RegisterClassEx fonksiyonunu kullanın ve pencere sınıf yapısını bir argüman olarak geçirin.

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

        return 1;
    }

  3. Şimdi bir pencere oluşturabilirsiniz.CreateWindow fonksiyonunu kullanın.

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

    Bu fonksiyon, bir pencere için bir tutamaç olan bir HWND döndürür.Daha fazla bilgi için, bkz. Windows Veri Türleri.

  4. Şimdi, pencereyi görüntülemek için aşağıdaki kodu kullanın.

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

    Bu durumda, görüntülenen pencerede çok içerik olmayacaktır çünkü henüz WndProc fonksiyonunu uygulamadınız.

  5. Şimdi işletim sisteminin gönderdiği iletileri dinlemek için bir ileti döngüsü ekleyin.Uygulama bir ileti aldığı zaman, bu döngü onu ele alınması için WndProc fonksiyonuna gönderir.İleti/Mesaj döngüsü aşağıdaki koda benzer.

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

    return (int) msg.wParam;

    İleti döngüsü içindeki yapı ve fonksiyonlar hakkında daha fazla bilgi için bkz. MSG, GetMessage, TranslateMessage, ve DispatchMessage.

    Bu noktada, WinMain fonksiyonu aşağıdaki koda benzemelidir.

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

WndProc fonksiyonuna işlevsellik eklemek için

  1. Uygulamanın aldığı iletileri yakalayan WndProc fonksiyonunu etkinleştirmek için bir switch ifadesi uygulayın/implemente edin.

    Yakalanmak için ilk ileti WM_PAINT iletisidir.Görüntülenen penceresinin parçası güncelleştirilmesi gerektiği zaman uygulama bu iletiyi alır.(Pencere ilk görüntülendiğinde, tümünün güncelleştirilmiş olması gerekir.)

    Bir WM_PAINT iletisi elde etmek için, önce BeginPaint'i çağırın, sonra metin, düğmeler ve penceredeki diğer denetimleri düzenleyen tüm mantığı elde edin ve sonra şunu çağırın: EndPaint.Bu uygulama için başlangıç çağrısı ve bitiş çağrısı arasındaki mantık "Hello World!" dizesini pencerede görüntülemektir.Aşağıdaki kodda, TextOut fonksiyonunun dize/string görüntülemeye alışık olduğuna dikkat edin.

    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. Bir uygulama genellikle diğer birçok iletileri de yakalar, örneğin, WM_CREATE ve WM_DESTROY.Aşağıdaki kod bir temel gösterir ama bütün WndProc fonksiyonunu.

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

Örnek

Bu örneği oluşturmak/derlemek için

  1. Daha önce "Win32 tabanlı bir proje oluşturmak için" gidiş yolunda gösterildiği gibi bir Win32 tabanlı proje oluşturun.

  2. Bu adımları takip eden aşağıdaki kodu kopyalayın ve GT_HelloWorldWin32.cpp kaynak dosyasına yapıştırın.

  3. Yapı menüsünde, Çözümü Derle'yi tıklatın.

  4. Uygulamayı çalıştırmak için F5 tuşuna basın.Ekranının sol üst köşesinde "Hello World!" metni içeren bir pencere görünür.

Bb384843.collapse_all(tr-tr,VS.110).gifKod

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

Ayrıca bkz.

Görevler

Windows uygulamaları (c++) oluşturma