Przewodnik: tworzenie tradycyjnej aplikacji klasycznej systemu Windows (C++)

W tym przewodniku pokazano, jak utworzyć tradycyjną aplikację klasyczną systemu Windows w programie Visual Studio. Utworzona aplikacja używa interfejsu API systemu Windows do wyświetlania komunikatu "Hello, Windows Desktop!" w oknie. Możesz użyć kodu opracowywanego w tym przewodniku jako wzorca do tworzenia aplikacji klasycznych systemu Windows.

Interfejs API systemu Windows (znany również jako interfejs API Win32, interfejs API pulpitu systemu Windows i klasyczny interfejs API systemu Windows) to oparta na języku C platforma do tworzenia aplikacji systemu Windows. Został on użyty do tworzenia aplikacji systemu Windows od dziesięcioleci. Bardziej zaawansowane i łatwiejsze w programach struktury zostały utworzone na podstawie interfejsu API systemu Windows. Na przykład MFC, ATL, platformy .NET. Nawet najbardziej nowoczesny kod środowisko wykonawcze systemu Windows dla aplikacji platformy UWP i Sklepu napisanych w języku C++/WinRT używa poniższego interfejsu API systemu Windows. Aby uzyskać więcej informacji na temat interfejsu API systemu Windows, zobacz Indeks interfejsu API systemu Windows.

Ważne

Na końcu tego dokumentu zostanie wyświetlona sekcja Kompilowanie kodu . W tym przewodniku omówiono różne fragmenty kodu, które przechodzą do aplikacji systemu Windows, ale nie będziesz kodować w miarę przechodzenia, ponieważ niektóre szczegóły zostały pominięte w fragmentach kodu, aby skupić się na najważniejszych częściach. Możesz skopiować pełny kod i wkleić go do projektu na końcu.

Wymagania wstępne

• Komputer z systemem Microsoft Windows 7 lub nowszym. Zalecamy korzystanie z systemu Windows 11 lub nowszego w celu uzyskania najlepszego środowiska programistycznego.

• Kopia programu Visual Studio. Aby uzyskać informacje na temat pobierania i instalowania programu Visual Studio, zobacz Instalowanie programu Visual Studio. Po uruchomieniu instalatora upewnij się, że jest zaznaczone pole Programowanie aplikacji klasycznych z obciążeniem języka C++ . Nie martw się, jeśli nie zainstalowano tego obciążenia podczas instalowania programu Visual Studio. Instalator można uruchomić ponownie i zainstalować go teraz.

  

• Podstawowa wiedza na temat używania środowiska IDE programu Visual Studio. Jeśli wcześniej używasz aplikacji klasycznych systemu Windows, prawdopodobnie możesz nadążyć. Aby zapoznać się z wprowadzeniem, zobacz Przewodnik po funkcji środowiska IDE programu Visual Studio.

• Zrozumienie wystarczającej ilości podstaw języka C++, które należy wykonać. Nie martw się, nie robimy nic zbyt skomplikowanego.

Tworzenie projektu klasycznego systemu Windows

Wykonaj następujące kroki, aby utworzyć pierwszy projekt klasyczny systemu Windows. Na początku tego przewodnika ukończony kod jest dostępny w sekcji Kompilowanie kodu na końcu przewodnika. Przejdź dalej i wykonaj kroki tworzenia projektu, ale wstrzymaj wklejanie poniższych sekcji kodu do końca, po wyświetleniu kompletnego kodu aplikacji. Niektóre szczegóły zostały pominięte w fragmentach kodu, aby skupić się na najważniejszych częściach. Możesz skopiować pełny kod i wkleić go do projektu na końcu.

Aby uprościć wyjaśnienie. Aby zapoznać się z dokumentacją preferowanej wersji programu Visual Studio, użyj kontrolki selektora wersji . Znajduje się on w górnej części spisu treści na tej stronie.

Aby utworzyć projekt klasyczny systemu Windows w programie Visual Studio

1. W menu głównym wybierz pozycję Plik>nowy>projekt, aby otworzyć okno dialogowe Tworzenie nowego projektu.

2. W górnej części okna dialogowego ustaw wartość Język na C++, ustaw wartość Platforma na Windows i ustaw wartość Typ projektu na Pulpit.

3. Z filtrowanej listy typów projektów wybierz pozycję Kreator pulpitu systemu Windows, a następnie wybierz pozycję Dalej. Na następnej stronie wprowadź nazwę projektu, na przykład DesktopApp.

4. Wybierz przycisk Utwórz, aby utworzyć projekt.

5. Zostanie wyświetlone okno dialogowe Projekt klasyczny systemu Windows. Na liście rozwijanej Typ aplikacji upewnij się, że wybrano pozycję Aplikacja klasyczna (.exe). Ponieważ tworzymy aplikację systemu Windows, wybranie opcji Aplikacja konsolowa powoduje utworzenie projektu, który nie zostanie skompilujący, biorąc pod uwagę kod, którego będziemy używać. Następnie w obszarze Dodatkowe opcje wybierz pozycję Pusty projekt. Wybierz przycisk OK , aby utworzyć projekt.

6. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt DesktopApp, wybierz pozycję Dodaj, a następnie wybierz pozycję Nowy element.

   

   Animacja pokazuje kliknięcie prawym przyciskiem myszy nazwy projektu w Eksplorator rozwiązań, wybranie pozycji Dodaj w wyświetlonym menu, a następnie wybranie pozycji Nowy element.

7. W oknie dialogowym Dodawanie nowego elementu wybierz pozycję Plik C++ (.cpp). W polu Nazwa wpisz nazwę pliku, na przykład HelloWindowsDesktop.cpp. Wybierz opcję Dodaj.

   

Projekt jest teraz tworzony i plik źródłowy jest otwierany w edytorze.

Kod

Następnie dowiedz się, jak utworzyć kod dla aplikacji klasycznej systemu Windows w programie Visual Studio.

Gdzie kod zaczyna działać w aplikacji klasycznej systemu Windows

1. Podobnie jak każda aplikacja języka C i aplikacja C++ musi mieć main funkcję jako punkt początkowy, każda aplikacja klasyczna WinMain systemu Windows musi mieć funkcję. WinMain ma następującą składnię.

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

   Aby uzyskać informacje o parametrach i zwracanej wartości tej funkcji, zobacz Punkt wejścia WinMain.

   Uwaga

   Jakie są wszystkie dodatkowe wyrazy, takie jak WINAPI, lub CALLBACK, lub HINSTANCE_In_? Tradycyjny interfejs API systemu Windows używa w szerokim zakresie definicji typów i makr preprocesora, aby wyodrębnić niektóre szczegóły typów i kodu specyficznego dla platformy, takie jak konwencje wywoływania, __declspec deklaracje i pragma kompilatora. W programie Visual Studio możesz użyć funkcji Szybkich informacji funkcji IntelliSense, aby zobaczyć definicje tych definicji typów i makr. Zatrzymaj wskaźnik myszy na interesującym cię słowie lub zaznacz go i naciśnij Ctrl K, Ctrl++I w przypadku małego okna podręcznego zawierającego definicję. Aby uzyskać więcej informacji, zobacz Using IntelliSense (Używanie funkcji IntelliSense). Parametry i typy zwracane często używają adnotacji SAL, aby ułatwić przechwytywanie błędów programowania. Aby uzyskać więcej informacji, zobacz Using SAL Annotations to Reduce C/C++ Code Defects (Używanie adnotacji SAL w celu zmniejszenia wad kodu C/C++).

2. Programy klasyczne systemu Windows wymagają programu <windows.h>. Zobaczysz również często wartość #include <tchar.h>. Ułatwia to pisanie aplikacji, która może pracować z elementem char lub wchar_t. Sposób jego działania polega na tym, że zamiast tego używasz TCHAR makra w kodzie, co ostatecznie wchar_t rozwiązuje problem, jeśli UNICODE symbol jest zdefiniowany w projekcie, w przeciwnym razie jest rozpoznawany jako char. Jeśli zawsze kompilujesz z włączonym formatem UNICODE, nie potrzebujesz TCHAR go i możesz po prostu użyć wchar_t bezpośrednio. Aby uzyskać więcej informacji, zobacz Using generic-text mappings (Używanie mapowań tekstu ogólnego). Poniższy kod przedstawia te dwie #include instrukcje w górnej części pliku.

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

3. Oprócz funkcji każda WinMain aplikacja klasyczna systemu Windows musi również mieć funkcję procedury okna. Ta funkcja jest nazywana elementem , ale można nadać jej dowolną WndProcnazwę w kodzie. WndProc ma następującą składnię.

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

   W tej funkcji napiszesz kod do obsługi komunikatów odbieranych przez aplikację z systemu Windows w przypadku wystąpienia zdarzeń . Jeśli na przykład użytkownik wybierze przycisk OK w aplikacji, system Windows wyśle ci komunikat. Kod jest pisany wewnątrz funkcji, która wykonuje dowolną WndProc pracę, jest odpowiednia. Jest to nazywane obsługą zdarzenia. Obsługujesz tylko zdarzenia, które są istotne dla aplikacji.

   Aby uzyskać więcej informacji, zobacz Procedury okien.

Dodawanie funkcji do WinMain funkcji

1. WinMain W funkcji należy przechwycić podstawowe informacje o oknie głównym. Można to zrobić, wypełniając strukturę typu WNDCLASSEX. Struktura zawiera informacje o oknie, takie jak ikona aplikacji, kolor tła okna, nazwa wyświetlana na pasku tytułu, między innymi. Co ważne, zawiera wskaźnik funkcji do procedury okna, która obsługuje komunikaty wysyłane przez system Windows do aplikacji. W poniższym przykładzie przedstawiono typową WNDCLASSEX strukturę:

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

   Aby uzyskać informacje o polach struktury powyżej, zobacz WNDCLASSEX.

2. WNDCLASSEX Po wypełnieniu struktury należy zarejestrować ją w systemie Windows, aby wiedziała o oknie i sposobie wysyłania do niego komunikatów. RegisterClassEx Użyj funkcji i przekaż strukturę klasy okna jako argument. Makro _T jest używane, ponieważ używamy TCHAR typu dla powyższej dyskusji na temat Unicode. Poniższy kod pokazuje, jak zarejestrować klasę okna.

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

3. Następnie utworzysz okno przy użyciu CreateWindowEx funkcji .

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

   Ta funkcja zwraca HWNDwartość , która jest dojściem do okna. Uchwyt jest nieco podobny do wskaźnika. System Windows używa go do śledzenia tworzonych okien. Aby uzyskać więcej informacji, zobacz Typy danych systemu Windows.

4. W tym momencie zostało utworzone okno, ale nadal musimy poinformować system Windows, aby był widoczny. To właśnie robi ten kod:

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

   Wyświetlone okno jest tylko pustym prostokątem, ponieważ nie zaimplementowano WndProc jeszcze funkcji. Aplikacja nie obsługuje jeszcze komunikatów wysyłanych przez system Windows.

5. Aby obsłużyć komunikaty, najpierw dodajemy to, co jest nazywane pętlą komunikatów w celu nasłuchiwania komunikatów wysyłanych przez system Windows. Gdy aplikacja otrzyma komunikat, ta pętla wysyła ją do funkcji WndProc , która ma być obsługiwana. Pętla komunikatów przypomina następujący kod:

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

   Aby uzyskać więcej informacji na temat struktur i funkcji w pętli komunikatów, zobacz MSG, GetMessageTranslateMessage i DispatchMessage.

   Podstawowa WinMain funkcja, która tworzy główne okno aplikacji i nasłuchuje komunikatów wysyłanych przez system Windows do aplikacji, przypomina następujący kod:

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

Obsługa komunikatów WndProc w funkcji

1. Aby obsłużyć komunikaty odbierane przez aplikację, należy zaimplementować instrukcję switch w WndProc funkcji.

   Ważnym komunikatem do obsługi jest WM_PAINT. Aplikacja otrzymuje komunikat, WM_PAINT gdy część wyświetlanego okna musi zostać zaktualizowana. Zdarzenie może wystąpić, gdy użytkownik przenosi okno przed oknem i przenosi go ponownie. Otrzymuje ten komunikat po pierwszym wyświetleniu okna, co daje szansę na wyświetlenie interfejsu użytkownika aplikacji. Aplikacja dowie się o tych zdarzeniach, gdy system Windows je wyśle. Po pierwszym wyświetleniu okna należy zaktualizować wszystko.

   Aby obsłużyć komunikat, najpierw wywołaj metodę WM_PAINT BeginPaint, a następnie obsłuż całą logikę, aby ułożyć tekst, przyciski i inne kontrolki w oknie. Następnie wywołaj metodę EndPaint. W przypadku tej aplikacji kod między elementami BeginPaint() i jest wyświetlany Hello, Windows desktop! w oknie utworzonym w programie WinMain()EndPaint() . W poniższym kodzie TextOut funkcja wyświetla tekst w określonej lokalizacji w oknie.

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

   W poprzednim kodzie HDC jest dojściem do kontekstu urządzenia, który jest skojarzony z obszarem klienta okna. Służy do rysowania w oknie w celu odwoływania się do obszaru klienta. BeginPaint Użyj funkcji iEndPaint, aby przygotować się do i ukończyć rysunek w obszarze klienta. BeginPaint Zwraca uchwyt do kontekstu urządzenia wyświetlania używanego do rysowania w obszarze klienta; EndPaint kończy żądanie malowania i zwalnia kontekst urządzenia.

2. Aplikacja zazwyczaj obsługuje wiele innych komunikatów. Na przykład WM_CREATE jest wysyłany po pierwszym utworzeniu okna i WM_DESTROY zamknięciu okna. Poniższy kod przedstawia podstawową, ale kompletną WndProc funkcję:

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

Kompilowanie kod

Zgodnie z obietnicą następuje kompletny kod dla działającej aplikacji.

Aby skompilować ten przykład

1. Usuń cały kod w HelloWindowsDesktop.cpp w edytorze. Skopiuj ten przykładowy kod i wklej go do 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. W menu Kompilacja wybierz pozycję Kompiluj rozwiązanie. Wyniki kompilacji są wyświetlane w oknie Dane wyjściowe w programie Visual Studio.

   

   Animacja pokazuje kliknięcie przycisku Zapisz wszystko, a następnie wybranie pozycji Kompiluj > Rozwiązanie kompilacji z menu głównego.

3. Aby uruchomić aplikację, naciśnij F5. Powinno zostać wyświetlone okno z tekstem "Hello, Windows Desktop!".

   

Gratulacje! Utworzono tradycyjną aplikację klasyczną systemu Windows.

Zobacz też

Typy aplikacji klasycznych systemu Windows C++