İzlenecek yol: Geleneksel bir Windows masaüstü uygulaması oluşturma (C++)

Bu kılavuzda Visual Studio'da geleneksel bir Windows masaüstü uygulamasının nasıl oluşturulacağı açıklanmaktadır. Oluşturduğunuz uygulama, Windows API'sini kullanarak Hello, Windows masaüstü! öğesini bir pencerede görüntüler. Windows masaüstü uygulamaları oluşturmak için bu kılavuzda geliştirdiğiniz kodu bir desen olarak kullanabilirsiniz.

Windows API'si (Win32 API, Windows Masaüstü API'si ve Windows Klasik API olarak da bilinir), Windows uygulamaları oluşturmaya yönelik C dili tabanlı bir çerçevedir. Onlarca yıldır Windows uygulamaları oluşturmak için kullanılmıştır. MFC, ATL ve .NET çerçeveleri gibi Windows API'sinin üzerinde daha gelişmiş ve daha kolay programlı çerçeveler oluşturulmuş. C++/WinRT dilinde yazılmış UWP ve Mağaza uygulamaları için en modern Windows Çalışma Zamanı kodu bile altındaki Windows API'sini kullanır. Windows API hakkında daha fazla bilgi için bkz . Windows API Dizini.

Önemli

The code içindeki kod blokları, açıklama amaçlı alıntılardır; ilerledikçe yapıştırmanız gereken adımlar değildir. Her kavramın daha kolay görülmesi için destekleyici kodu atlarlar. Boş projeyi oluşturduktan sonra Kodu derleme'deki eksiksiz, derlenebilir kaynağı kullanın.

Önkoşullar

• Microsoft Windows 7 veya sonraki sürümleri. En iyi geliştirme deneyimi için Windows 11 veya üzerini öneririz.

• Visual Studio. Visual Studio'yu indirme ve yükleme hakkında bilgi için bkz . Visual Studio'yu Yükleme. Yükleyiciyi çalıştırdığınızda, Desktop development with C++ iş yükünün seçili olduğundan emin olun. Visual Studio'yu yüklerken bu iş yükünü yüklemediyseniz endişelenmeyin. Yükleyiciyi yeniden çalıştırabilir ve şimdi yükleyebilirsiniz.

  

• Visual Studio IDE'nin nasıl kullanılacağına ilişkin temel bilgiler. Windows masaüstü uygulamalarını daha önce kullandıysanız, büyük olasılıkla devam edebilirsiniz. Giriş için bkz . Visual Studio IDE özellik turu.

• C++ dili hakkında bazı bilgiler. Merak etme, çok karmaşık bir şey yapmayız.

Windows masaüstü projesi oluşturma

İlk Windows masaüstü projenizi oluşturmak için bu adımları izleyin. Siz devam ettikçe kod alıntılarını tek tek yapıştırmayın. Projeyi oluşturduktan sonra Kodu derleme bölümünde tam kaynağı kullanın.

Tercih ettiğiniz Visual Studio sürümünün adımlarını görmek için bu sayfadaki içindekiler tablosunun en üstünde bulunan Sürüm seçiciyi kullanın.

Visual Studio'da Windows masaüstü projesi oluşturmak için

1. Ana menüden Dosya>Yeni>Proje Oluştur iletişim kutusunu açın.

2. İletişim kutusunun üst kısmında Dil'i C++ olarak, Platform'ı Windows olarak ve Proje türünü Masaüstü olarak ayarlayın.

3. Filtrelenen proje türleri listesinden Windows Masaüstü Sihirbazı'nı ve ardından İleri'yi seçin. Sonraki sayfada, proje için desktopapp gibi bir ad girin.

4. Projeyi oluşturmak için Oluştur düğmesini seçin.

5. Artık Windows Masaüstü Projesi iletişim kutusu görüntülenir. Uygulama türü açılan listesinde Masaüstü uygulaması (.exe) öğesini seçtiğinizden emin olun. Bir Windows uygulaması yaptığımız için Konsol Uygulaması'nın seçilmesi, kullanacağımız koda göre derlenmeyecek bir projeyle sonuçlaşır. Ardından, Ek seçenekler'in altında Projeyi boşalt'ı seçin. Projeyi oluşturmak için Tamam'ı seçin.

6. Çözüm Gezgini DesktopApp projesine sağ tıklayın, Ekle'yi ve ardından Yeni Öğe'yi seçin.

   

   Animasyonda, Çözüm Gezgini proje adına sağ tıklanması, görüntülenen menüden Ekle'nin seçilmesi ve ardından Yeni Öğe'nin seçilmesi gösterilir.

7. Yeni Öğe Ekle iletişim kutusunda C++ Dosyası (.cpp) öğesini seçin. Ad kutusuna dosya için bir ad yazın; örneğin, HelloWindowsDesktop.cpp. Ekle'yi seçin.

   

Projeniz oluşturulur ve kaynak dosyanız düzenleyicide açılır.

Kod

Ardından, Visual Studio'da bir Windows masaüstü uygulaması için kod oluşturmayı öğrenin.

Program birlikte nasıl uyum sağlar?

Geleneksel bir Windows masaüstü uygulaması, bir pencere görüntüleyebilmesi için önce birkaç kurulum kodu kullanır:

Program bölümü	Purpose
Üst bilgiler ve paylaşılan bildirimler	Windows türleri sağlayın ve birden çok işlev tarafından kullanılan değerleri bildirin.
WinMain	Pencere sınıfını kaydeder, pencereyi oluşturup görüntüler ve ileti döngüsünü çalıştırır.
WndProc	pencereyi boyama veya kapatma istekleri gibi Windows iletileri işler.

Aşağıdaki alıntılar, programın bir kerede bir bölümüne odaklanır. Tam kaynak, parçaları doğru sırada birleştirir.

Windows masaüstü uygulamasında kodun çalışmaya başladığı yer

1. Her C uygulamasının ve C++ uygulamasının başlangıç noktası olarak bir main işlevi olması gerektiği gibi, her Windows masaüstü uygulamasının da bir WinMain işlevi olmalıdır. WinMain aşağıdaki söz dizimine sahiptir.

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

   Bu işlevin parametreleri ve dönüş değeri hakkında bilgi için bkz. WinMain giriş noktası.

   Not

   Tüm bu ek sözcükler nelerdir, örneğin, veya WINAPI, ya da CALLBACKHINSTANCE?_In_ Geleneksel Windows API'sinde tür tanımları ve önişlemci makroları, çağırma kuralları, __declspec bildirimler ve derleyici pragmaları gibi tür ve platforma özgü kod ayrıntılarını soyutlama amacıyla kapsamlı olarak kullanılır. Visual Studio'da, bu tür tanımlarının ve makroların ne tanımladığına bakmak için IntelliSense Hızlı Bilgi özelliğini kullanabilirsiniz. İlgilendiğiniz sözcüğün üzerine farenizi getirin ya da sözcüğü seçip tanımı içeren küçük bir açılır pencere açmak için Ctrl+K, Ctrl+I tuşlarına basın. Daha fazla bilgi için IntelliSense Kullanımı konusuna bakın. Parametreler ve dönüş türleri genellikle programlama hatalarını yakalamanıza yardımcı olmak için SAL Ek Açıklamaları kullanır. Daha fazla bilgi için bkz . C/C++ Kod Hatalarını Azaltmak için SAL Ek Açıklamalarını Kullanma.

2. Windows masaüstü programları <windows.h> gerektirir. Ayrıca sık sık görürsünüz #include <tchar.h>. Bu, char ya da wchar_t ile çalışabilecek bir uygulama yazmayı kolaylaştırmak içindir. Bunun yerine kodunuzda makroyu TCHAR kullanmanız işe yarar. TCHAR, projeniz UNICODE simgesini tanımladığında wchar_t olarak değerlendirilir; aksi takdirde char olarak değerlendirilir. UNICODE her zaman etkinleştirilmiş olarak derleme yapıyorsanız, TCHAR kullanmanıza gerek yoktur ve wchar_t öğesini doğrudan kullanabilirsiniz. Daha fazla bilgi için bkz . Genel metin eşlemelerini kullanma. Aşağıdaki kod, dosyanın en üstünde bu iki #include deyimi gösterir.

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

3. WinMain işlevinin yanı sıra, her Windows masaüstü uygulamasının bir pencere yordamı işlevi de olmalıdır. Bu izlenecek yol işlevine WndProcadını verir, ancak kodunuzda istediğiniz adı verebilirsiniz. WndProc aşağıdaki söz dizimine sahiptir.

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

   Bu işlevde, olaylar gerçekleştiğinde uygulamanın Windows'tan aldığı iletileri işlemek için kod yazarsınız. Örneğin, bir kullanıcı uygulamanızda tamam düğmesini seçerse Windows size bir ileti gönderir. Uygun olan her işi yerine getiren bir WndProc işlevin içine kod yazarsınız. Buna olay işleme denir. Yalnızca uygulamanızla ilgili olayları işlersiniz.

   Daha fazla bilgi için bkz. Pencere Yordamları.

WinMain fonksiyonuna işlevsellik ekleme

öncesinde WinMain, programın diğer bölümlerinin kullandığı değerleri ve pencere yordamını bildirin. Bu bildirimler, kaynağın tamamında WinMain öncesinde görünür:

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

// Stored instance handle for use in Win32 API calls such as FindResource.
HINSTANCE hInst;

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

1. işlevinde WinMain , ana pencerenizle ilgili bazı temel bilgileri yakalamanız gerekir. Bunu, WNDCLASSEX türünde bir yapı doldurarak yaparsınız. Yapı, uygulama simgesi, pencerenin arka plan rengi, başlık çubuğunda görüntülenecek ad gibi pencere hakkındaki bilgileri ve diğer öğeleri içerir. Önemli olan, Windows'un uygulamanıza gönderdiği iletileri işleyen pencere yordamınıza yönelik bir işlev işaretçisi içerir. Aşağıdaki örnekte tipik WNDCLASSEX bir yapı gösterilmektedir:

   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(wcex.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);
   

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

2. WNDCLASSEX yapısını doldurduktan sonra, Windows’un pencerenizi tanıması ve iletileri ona nasıl göndereceğini bilmesi için bunu Windows’a kaydedin. RegisterClassEx işlevini kullanın ve pencere sınıfı yapısını argüman olarak iletin. _T makrosu, Unicode ile ilgili önceki açıklamada belirtildiği gibi, dize sabitinin TCHAR tarafından seçilen karakter türüyle eşleşmesini sağlar. Aşağıdaki kod, pencere sınıfının nasıl kaydedileceklerini gösterir.

   if (!RegisterClassEx(&wcex))
   {
      MessageBox(NULL,
         _T("Call to RegisterClassEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

3. işlevini kullanarak CreateWindowEx bir pencere oluşturun.

   // The parameters to CreateWindowEx explained:
   // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
   // 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, height)
   // NULL: the parent of this window
   // NULL: this application doesn't have a menu bar
   // hInstance: the first parameter from WinMain
   // NULL: not used in this application
   HWND hWnd = CreateWindowEx(
   WS_EX_OVERLAPPEDWINDOW,
      szWindowClass,
      szTitle,
      WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT,
      500, 100,
      NULL,
      NULL,
      hInstance,
      NULL
   );
   if (!hWnd)
   {
      MessageBox(NULL,
         _T("Call to CreateWindowEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

   Bu işlev, bir pencerenin tanıtıcısı olan bir HWND döndürür. Bir işleyici biraz işaretçiye benzer. Windows, oluşturduğunuz pencereleri izlemek için bunu kullanır. Daha fazla bilgi için bkz . Windows Veri Türleri.

4. Bu noktada pencere oluşturulmuştur, ancak yine de Windows'a bunu görünür hale getirmesini söylememiz gerekir. Bu kodun yaptığı budur:

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

   İşlevi henüz uygulamadığınız için görüntülenen pencere yalnızca boş bir dikdörtgendir WndProc . Uygulama henüz Windows'un gönderdiği iletileri işlemez.

5. İletileri işlemek için öncelikle Windows'un gönderdiği iletileri dinlemek için ileti döngüsü olarak adlandırılan bir döngü ekleriz. Uygulama bir ileti aldığında, bu döngü işlenmek üzere bu iletiyi işlevinize WndProc iletir. İleti 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ündeki yapılar ve işlevler hakkında daha fazla bilgi için bkz MSG. , GetMessage, TranslateMessage ve DispatchMessage.

   Uygulamanın ana penceresini oluşturan ve Windows'un uygulamanızı gönderdiği iletileri dinleyen temel WinMain bir işlev aşağıdaki koda benzer:

   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(wcex.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 CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // 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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindowEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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;
   }
   

İletileri WndProc işlevinde işleme

1. Uygulamanın aldığı iletileri işlemek için işlevinizde switch bir WndProc deyim uygularsınız.

   Ele alınması gereken önemli bir mesaj: WM_PAINT. Uygulama, görüntülenen penceresinin bir bölümünün güncelleştirilmiş olması gerektiğinde bir WM_PAINT ileti alır. Bu olay, kullanıcı bir pencereyi sizin pencerenizin önüne getirip ardından tekrar uzaklaştırdığında gerçekleşebilir. Pencereniz ilk kez görüntülendiğinde bu iletiyi alır ve uygulama kullanıcı arabiriminizi görüntüleme fırsatı verir. Uygulamanız bu olayları Windows gönderdiğinde öğrenir. Pencere ilk kez görüntülendiğinde, tümünün güncelleştirilmiş olması gerekir.

   İletiyi WM_PAINT işlemek için önce çağrısı BeginPaintyapın, ardından metin, düğme ve diğer denetimleri pencereye yerleştirmeye ilişkin tüm mantığı işleyin. Ardından EndPaint çağırın. Bu uygulamada, BeginPaint() ile EndPaint() arasındaki kod, WinMain() içinde oluşturduğunuz pencerede Hello, Windows desktop! görüntüler. Aşağıdaki kodda TextOut işlev, metni pencerede belirtilen konumda görüntüler.

   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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   Önceki kodda, HDC pencerenin istemci alanıyla ilişkilendirilmiş bir cihaz bağlamının tanıtıcısıdır. Pencerede çizim yaparken, istemci alanına başvurmak için bu tutamacı kullanın. İstemci alanında çizimi hazırlamak ve tamamlamak için BeginPaint ve EndPaint işlevlerini kullanın. BeginPaint istemci alanında çizim için kullanılan görüntü cihazı bağlamının tutamacını döndürür; EndPaint boya isteğini sonlandırır ve cihaz bağlamını serbest bırakır.

2. Bir uygulama genellikle diğer birçok iletiyi işler. Örneğin, WM_CREATE bir pencere ilk oluşturulduğunda ve WM_DESTROY pencere kapatıldığında gönderilir. Aşağıdaki kod, temel ama eksiksiz WndProc bir işlevi gösterir:

   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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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;
   }
   

Kodu oluşturma

Söz verilen şekilde, çalışan uygulamanın tam kodu aşağıdaki gibidir.

Bu örneği oluşturmak için

1. Düzenleyicideki tüm kodu HelloWindowsDesktop.cpp silin. Bu örnek kodu kopyalayın ve içine HelloWindowsDesktop.cppyapıştırın:

   // HelloWindowsDesktop.cpp
   // compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c
   
   #include <windows.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");
   
   // Stored instance handle for use in Win32 API calls such as FindResource.
   HINSTANCE hInst;
   
   // Forward declarations of functions included in this code module:
   LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
   
   int WINAPI 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(wcex.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 CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // 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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindowEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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. Build menüsünde Çözümü Derle seçeneğini belirleyin. Derlemenin sonuçları Visual Studio'daki Çıkış penceresinde görünür.

   

   Animasyonda tümünü kaydet düğmesine tıkladıktan sonra ana menüden Derleme > Derleme Çözümü'ne tıklanması gösterilir.

3. Uygulamayı çalıştırmak için F5 tuşuna basın. Metin Hello, Windows desktop! içeren bir pencere görünmelidir.

   

Tebrikler! Geleneksel bir Windows masaüstü uygulaması oluşturdunuz.

Ayrıca bkz.

• Windows C++ masaüstü uygulama türleri