Panduan: Membuat aplikasi Windows Desktop tradisional (C++)

Panduan ini menunjukkan cara membuat aplikasi desktop Windows tradisional di Visual Studio. Aplikasi yang Anda buat menggunakan WINDOWS API untuk menampilkan "Halo, desktop Windows!" di jendela. Anda dapat menggunakan kode yang Anda kembangkan dalam panduan ini sebagai pola untuk membuat aplikasi desktop Windows.

WINDOWS API (juga dikenal sebagai WIN32 API, Windows Desktop API, dan Windows Classic API) adalah kerangka kerja berbasis bahasa C untuk membuat aplikasi Windows. Ini telah digunakan untuk membuat aplikasi Windows selama beberapa dekade. Kerangka kerja yang lebih canggih dan lebih mudah diprogram telah dibangun di atas Windows API. Misalnya, MFC, ATL, kerangka kerja .NET. Bahkan kode Windows Runtime paling modern untuk aplikasi UWP dan Store yang ditulis dalam C++/WinRT menggunakan WINDOWS API di bawahnya. Untuk informasi selengkapnya tentang Windows API, lihat Indeks WINDOWS API.

Penting

Bagian Bangun kode di akhir dokumen ini memperlihatkan kode lengkap. Panduan ini mencakup berbagai potongan kode yang masuk ke aplikasi Windows, tetapi Anda tidak akan membuat kode saat Anda pergi karena beberapa detail dihilangkan dalam cuplikan kode untuk fokus pada bagian yang paling penting. Anda dapat menyalin kode lengkap dan menempelkannya ke proyek Anda di akhir.

Prasyarat

• Komputer yang menjalankan Microsoft Windows 7 atau versi yang lebih baru. Kami merekomendasikan Windows 11 atau yang lebih baru untuk pengalaman pengembangan terbaik.

• Salinan Visual Studio. Untuk informasi tentang cara mengunduh dan menginstal Visual Studio, lihat Menginstal Visual Studio. Saat Anda menjalankan alat penginstal, pastikan bahwa pengembangan Desktop dengan beban kerja C++ dicentang. Jangan khawatir jika Anda tidak menginstal beban kerja ini saat menginstal Visual Studio. Anda dapat menjalankan alat penginstal lagi dan menginstalnya sekarang.

  

• Pemahaman dasar tentang menggunakan Ide Visual Studio. Jika Anda telah menggunakan aplikasi desktop Windows sebelumnya, Anda mungkin dapat mengikutinya. Untuk pengenalan, lihat tur fitur Visual Studio IDE.

• Pemahaman tentang cukup tentang dasar-dasar bahasa C++ untuk diikuti. Jangan khawatir, kami tidak melakukan sesuatu yang terlalu rumit.

Membuat proyek desktop Windows

Ikuti langkah-langkah ini untuk membuat proyek desktop Windows pertama Anda. Sesuai catatan di awal panduan ini, kode yang diselesaikan tersedia di bagian Bangun kode di akhir panduan. Lanjutkan dan ikuti langkah-langkah untuk membuat proyek, tetapi tahan menempelkan bagian kode berikut hingga akhir, saat kode aplikasi lengkap disajikan. Beberapa detail dihilangkan dalam cuplikan kode untuk berfokus pada bagian yang paling penting. Anda dapat menyalin kode lengkap dan menempelkannya ke proyek Anda di akhir.

Untuk menyederhanakan penjelasan. Untuk melihat dokumentasi untuk versi Visual Studio pilihan Anda, gunakan kontrol pemilih Versi. Ini terletak di bagian atas daftar isi di halaman ini.

Untuk membuat proyek desktop Windows di Visual Studio

1. Dari menu utama, pilih File>Baru>Proyek untuk membuka kotak dialog Buat Proyek Baru.

2. Di bagian atas dialog, atur Bahasa ke C++, atur Platform ke Windows, dan atur Jenis proyek ke Desktop.

3. Dari daftar tipe proyek yang difilter, pilih Windows Desktop Wizard lalu pilih Berikutnya. Di halaman berikutnya, masukkan nama untuk proyek, misalnya, DesktopApp.

4. Pilih tombol Buat untuk membuat proyek.

5. Dialog Proyek Desktop Windows sekarang muncul. Di menu dropdown Jenis aplikasi, pastikan Anda memilih Aplikasi desktop (.exe). Karena kami membuat aplikasi Windows, memilih Aplikasi Konsol menghasilkan proyek yang tidak akan dibuat mengingat kode yang akan kami gunakan. Lalu, di bawah Opsi tambahan, pilih Kosongkan proyek. Pilih OK untuk membuat proyek.

6. Di Penjelajah Solusi, klik kanan proyek DesktopApp, pilih Tambahkan, lalu pilih Item Baru.

   

   Animasi memperlihatkan mengklik kanan pada nama proyek di Penjelajah Solusi, memilih Tambahkan di menu yang muncul, lalu memilih Item Baru.

7. Dalam kotak dialog Tambahkan Item Baru, pilih File C++ (.cpp). Dalam kotak Nama , ketik nama untuk file, misalnya, HelloWindowsDesktop.cpp. Pilih Tambahkan.

   

Proyek Anda sekarang dibuat dan file sumber Anda dibuka di editor.

Kode

Selanjutnya, pelajari cara membuat kode untuk aplikasi desktop Windows di Visual Studio.

Di mana kode mulai berjalan di aplikasi desktop Windows

1. Sama seperti setiap aplikasi C dan aplikasi C++ harus memiliki main fungsi sebagai titik awalnya, setiap aplikasi desktop Windows harus memiliki WinMain fungsi. WinMain memiliki sintaks berikut.

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

   Untuk informasi tentang parameter dan nilai pengembalian fungsi ini, lihat Titik masuk WinMain.

   Catatan

   Apa saja kata tambahan tersebut, seperti WINAPI, atau CALLBACK, atau HINSTANCE, atau _In_? WINDOWS API tradisional menggunakan typedefs dan makro praprosesor secara luas untuk mengabstraksi beberapa detail jenis dan kode khusus platform, seperti konvensi panggilan, __declspec deklarasi, dan pragma kompilator. Di Visual Studio, Anda dapat menggunakan fitur Info Cepat IntelliSense untuk melihat definisi typedefs dan makro ini. Arahkan mouse Anda ke kata yang menarik, atau pilih dan tekan Ctrl+K, Ctrl+I untuk jendela pop-up kecil yang berisi definisi. Untuk informasi selengkapnya, lihat Menggunakan IntelliSense. Parameter dan jenis pengembalian sering menggunakan Anotasi SAL untuk membantu Anda menangkap kesalahan pemrograman. Untuk informasi selengkapnya, lihat Menggunakan Anotasi SAL untuk Mengurangi Cacat Kode C/C++.

2. Program desktop Windows memerlukan <windows.h>. Anda juga akan sering melihat #include <tchar.h>. Itu untuk mempermudah penulisan aplikasi yang dapat bekerja dengan char atau wchar_t. Cara kerjanya adalah Anda menggunakan TCHAR makro dalam kode Anda, yang pada akhirnya wchar_t menyelesaikan jika UNICODE simbol ditentukan dalam proyek Anda, jika tidak, itu diselesaikan ke char. Jika Anda selalu membangun dengan UNICODE diaktifkan, Anda tidak perlu TCHAR dan hanya dapat menggunakannya wchar_t secara langsung. Untuk informasi selengkapnya, lihat Menggunakan pemetaan teks generik. Kode berikut menunjukkan dua #include pernyataan ini di bagian atas file.

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

3. Seiring dengan WinMain fungsi, setiap aplikasi desktop Windows juga harus memiliki fungsi prosedur jendela. Fungsi ini disebut WndProc, tetapi Anda dapat memberikan nama apa pun yang Anda suka dalam kode Anda. WndProc memiliki sintaks berikut.

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

   Dalam fungsi ini, Anda menulis kode untuk menangani pesan yang diterima aplikasi dari Windows ketika peristiwa terjadi. Misalnya, jika pengguna memilih tombol OK di aplikasi Anda, Windows mengirimkan pesan kepada Anda. Anda menulis kode di dalam WndProc fungsi yang melakukan pekerjaan apa pun yang sesuai. Ini disebut menangani peristiwa. Anda hanya menangani peristiwa yang relevan untuk aplikasi Anda.

   Untuk informasi selengkapnya, lihat Prosedur Jendela.

Menambahkan fungsionalitas ke WinMain fungsi

1. Dalam fungsi ini WinMain , Anda perlu mengambil beberapa informasi dasar tentang jendela utama Anda. Anda melakukannya dengan mengisi struktur jenis WNDCLASSEX. Struktur berisi informasi tentang jendela seperti ikon aplikasi, warna latar belakang jendela, nama yang akan ditampilkan di bilah judul, antara lain. Yang penting, ini berisi penunjuk fungsi ke prosedur jendela Anda yang menangani pesan yang dikirim Windows ke aplikasi Anda. Contoh berikut menunjukkan struktur umum 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(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);
   

   Untuk informasi tentang bidang struktur di atas, lihat WNDCLASSEX.

2. Setelah struktur WNDCLASSEX terisi, Anda mendaftarkannya dengan Windows sehingga tahu tentang jendela Anda dan cara mengirim pesan ke dalamnya. RegisterClassEx Gunakan fungsi dan teruskan struktur kelas jendela sebagai argumen. _T Makro digunakan karena kita menggunakan TCHAR jenis per diskusi tentang Unicode di atas. Kode berikut menunjukkan cara mendaftarkan kelas jendela.

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

3. Selanjutnya Anda membuat jendela menggunakan CreateWindowEx fungsi .

   static TCHAR szWindowClass[] = _T("DesktopApp");
   static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
   
   // 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, 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 = 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;
   }
   

   Fungsi ini mengembalikan HWND, yang merupakan handel ke jendela. Handel agak seperti penunjuk. Windows menggunakannya untuk melacak jendela yang Anda buat. Untuk informasi selengkapnya, lihat Jenis Data Windows.

4. Pada titik ini, jendela telah dibuat, tetapi kita masih perlu memberi tahu Windows untuk membuatnya terlihat. Itulah yang dilakukan kode ini:

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

   Jendela yang ditampilkan hanya persegi panjang kosong karena Anda belum menerapkan WndProc fungsi. Aplikasi belum menangani pesan yang sekarang dikirim Windows ke dalamnya.

5. Untuk menangani pesan, kami terlebih dahulu menambahkan apa yang disebut perulangan pesan untuk mendengarkan pesan yang dikirim Windows. Ketika aplikasi menerima pesan, perulangan ini mengirimkannya ke fungsi Anda WndProc untuk ditangani. Perulangan pesan menyerupan kode berikut:

   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }
   
   return (int) msg.wParam;
   

   Untuk informasi selengkapnya tentang struktur dan fungsi dalam perulangan pesan, lihat MSG, , GetMessageTranslateMessage, dan DispatchMessage.

   Fungsi dasar WinMain yang membuat jendela utama aplikasi, dan mendengarkan pesan yang dikirim Windows aplikasi Anda, akan menyerupai kode berikut:

   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, 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 = 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 CreateWindow failed!"),
            _T("Windows Desktop 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;
   }
   

Menangani pesan dalam WndProc fungsi

1. Untuk menangani pesan yang diterima aplikasi, Anda menerapkan switch pernyataan dalam fungsi Anda WndProc .

   Pesan penting untuk ditangani adalah WM_PAINT. Aplikasi menerima WM_PAINT pesan ketika bagian dari jendela yang ditampilkan harus diperbarui. Peristiwa dapat terjadi ketika pengguna memindahkan jendela di depan jendela Anda dan memindahkannya lagi. Ini menerima pesan ini saat pertama kali jendela Anda ditampilkan, memberi Anda kesempatan untuk menampilkan antarmuka pengguna aplikasi Anda. Aplikasi Anda mencari tahu tentang peristiwa ini ketika Windows mengirimnya. Ketika jendela pertama kali ditampilkan, semua jendela harus diperbarui.

   Untuk menangani WM_PAINT pesan, pertama-tama panggil BeginPaint, lalu tangani semua logika untuk meletakkan teks, tombol, dan kontrol lainnya di jendela. Kemudian hubungi EndPaint. Untuk aplikasi ini, kode antara BeginPaint() dan EndPaint() tampilan Hello, Windows desktop! di jendela yang Anda buat di WinMain(). Dalam kode berikut, TextOut fungsi menampilkan teks di lokasi yang ditentukan di jendela.

   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, _tcslen(greeting));
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   Dalam kode sebelumnya, HDC adalah handel ke konteks perangkat yang terkait dengan area klien jendela. Anda menggunakannya saat menggambar di jendela untuk merujuk ke area kliennya. BeginPaint Gunakan fungsi dan EndPaint untuk mempersiapkan dan menyelesaikan gambar di area klien. BeginPaint mengembalikan handel ke konteks perangkat tampilan yang digunakan untuk menggambar di area klien; EndPaint mengakhiri permintaan cat dan merilis konteks perangkat.

2. Aplikasi biasanya menangani banyak pesan lain. Misalnya, WM_CREATE dikirim saat jendela pertama kali dibuat, dan WM_DESTROY saat jendela ditutup. Kode berikut menunjukkan fungsi dasar tetapi lengkap WndProc :

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

Bangun kode

Seperti yang dijanjikan, kode lengkap untuk aplikasi kerja mengikuti.

Untuk membangun contoh ini

1. Hapus semua kode di HelloWindowsDesktop.cpp di editor. Salin kode contoh ini dan tempelkan ke HelloWindowsDesktop.cpp:

   // HelloWindowsDesktop.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("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, 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 = 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 CreateWindow failed!"),
            _T("Windows Desktop 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, 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, _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;
   }
   

2. Pada menu Build, pilih Buat Solusi. Hasil kompilasi muncul di jendela Output di Visual Studio.

   

   Animasi menunjukkan mengklik tombol simpan semua, lalu memilih Build > Build Solution dari menu utama.

3. Untuk menjalankan aplikasi, tekan F5. Jendela dengan teks "Halo, desktop Windows!" akan muncul.

   

Selamat! Anda telah membangun aplikasi desktop Windows tradisional.

Lihat juga

Jenis aplikasi desktop Windows C++