Návod: Vytvoření tradiční desktopové aplikace pro Windows (C++)

Tento názorný postup vysvětluje, jak v sadě Visual Studio vytvořit tradiční desktopovou aplikaci pro Windows. Aplikace, kterou vytvoříte, používá rozhraní API systému Windows k zobrazení Hello, plochy Windows! v okně. Kód, který vyvíjíte v tomto názorném postupu, můžete použít jako vzor k vytváření desktopových aplikací pro Windows.

Rozhraní API systému Windows (označované také jako rozhraní API Win32, desktopové rozhraní API systému Windows a klasické rozhraní API pro Windows) je architektura založená na jazyce C pro vytváření aplikací pro Windows. Používá se k vytváření aplikací pro Windows po celá desetiletí. Pokročilejší a snadněji programové architektury jsou postavené na rozhraní API systému Windows, například rozhraní MFC, ATL a rozhraní .NET. I ten nejmodernější kód prostředí Windows Runtime pro aplikace UWP a Store napsaný v jazyce C++/WinRT v pozadí využívá rozhraní Windows API. Další informace o rozhraní API systému Windows naleznete v tématu Index rozhraní API systému Windows.

Důležité

Bloky kódu v The code jsou vysvětlující ukázky, ne kroky, které máte průběžně vkládat. Vynechají podpůrný kód, aby se každý koncept snadněji viděl. Po vytvoření prázdného projektu použijte úplný, sestavitelný zdroj v sestavení kódu.

Požadavky

• Microsoft Windows 7 nebo novější verze. Pro nejlepší vývojové prostředí doporučujeme Windows 11 nebo novější.

• Visual Studio. Informace o tom, jak stáhnout a nainstalovat Visual Studio, naleznete v tématu Instalace sady Visual Studio. Při spuštění instalačního programu se ujistěte, že je zaškrtnutá úloha Vývoj desktopových aplikací v jazyce C++. Nedělejte si starosti, pokud jste tuto úlohu nenainstalovali při instalaci sady Visual Studio. Instalační program můžete spustit znovu a nainstalovat ho.

  

• Základní znalosti o tom, jak používat integrované vývojové prostředí sady Visual Studio. Pokud jste už dřív používali desktopové aplikace pro Windows, pravděpodobně budete mít přehled. Úvod najdete v tématu Prohlídka funkcí integrovaného vývojového prostředí sady Visual Studio.

• Znalost jazyka C++. Nemějte obavy, neděláme nic moc složitého.

Vytvoření desktopového projektu Windows

Podle těchto kroků vytvořte svůj první desktopový projekt Windows. Při přechodu nevkládejte jednotlivé výňatky kódu. Po vytvoření projektu použijte úplný zdroj v sestavení kódu.

Pokud chcete zobrazit postup pro upřednostňovanou verzi sady Visual Studio, použijte selektor verzí umístěný v horní části obsahu na této stránce.

Vytvoření desktopového projektu Windows v sadě Visual Studio

1. V hlavní nabídce zvolte Soubor>nový>projekt a otevřete dialogové okno Vytvořit nový projekt.

2. V horní části dialogového okna nastavte jazyk na C++, nastavte platformu pro Windows a nastavte typ projektu na Desktop.

3. V filtrovaném seznamu typů projektů zvolte Průvodce plochou systémem Windows a pak zvolte Další. Na další stránce zadejte název projektu, například DesktopApp.

4. Zvolte tlačítko Vytvořit a vytvořte projekt.

5. Zobrazí se dialogové okno Desktopový projekt windows. V rozevíracím seznamu Typ aplikace se ujistěte, že jste vybrali Desktopovou aplikaci (.exe). Protože vytváříme aplikaci pro Windows, povede volba konzolové aplikace k projektu, který s kódem, který budeme používat, nepůjde sestavit. Potom v části Další možnosti vyberte Prázdný projekt. Zvolte OK a vytvořte projekt.

6. V Průzkumník řešení klikněte pravým tlačítkem na projekt DesktopApp, zvolte Přidat a pak zvolte Nová položka.

   

   Animace zobrazuje kliknutí pravým tlačítkem myši na název projektu v Průzkumníku řešení, výběr možnosti Přidat v zobrazené nabídce a následně položky Nová položka.

7. V dialogovém okně Přidat novou položku vyberte soubor C++ (.cpp). Do pole Název zadejte název souboru, HelloWindowsDesktop.cppnapříklad . Zvolte položku Přidat.

   

Projekt se teď vytvoří a zdrojový soubor se otevře v editoru.

Kód

Dále se dozvíte, jak v sadě Visual Studio vytvořit kód pro desktopovou aplikaci pro Windows.

Jak program zapadá dohromady

Tradiční desktopová aplikace Windows používá před zobrazením okna několik částí instalačního kódu:

Část programu	Purpose
Hlavičky a sdílené deklarace	Zadejte Windows typy a deklarujte hodnoty používané více funkcemi.
WinMain	Zaregistruje třídu okna, vytvoří a zobrazí okno a spustí smyčku zpráv.
WndProc	Zpracovává zprávy z Windows, například žádosti o vykreslení nebo zavření okna.

Následující výňatek se zaměřuje na jednu část programu najednou. Kompletní zdroj kombinuje části ve správném pořadí.

Kde se spustí kód v desktopové aplikaci pro Windows

1. Stejně jako každá aplikace jazyka C a aplikace jazyka C++ musí mít main funkci jako výchozí bod, každá desktopová aplikace windows musí mít WinMain funkci. WinMain má následující syntaxi.

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

   Informace o parametrech a návratové hodnotě této funkce naleznete v tématu vstupní bod WinMain.

   Poznámka:

   Jaká jsou všechna tato nadbytečná slova, například WINAPI, nebo CALLBACK, nebo HINSTANCE, nebo _In_? Tradiční rozhraní API systému Windows používá typedefs a makra preprocesoru, která výrazně abstrahují některé podrobnosti o typech a kódu specifickém pro platformu, jako jsou konvence volání, __declspec deklarace a direktivy kompilátoru. V sadě Visual Studio můžete pomocí funkce Rychlé informace technologie IntelliSense zjistit, co tyto definice typedefs a makra definují. Najeďte myší na slovo, které vás zajímá, nebo ho vyberte a stiskněte Ctrl+K, Ctrl+I. Otevře se malé vyskakovací okno, které obsahuje definici. Další informace najdete v tématu Použití technologie IntelliSense. Parametry a návratové typy často používají poznámky SAL k zachycení programovacích chyb. Další informace naleznete v tématu Použití poznámek SAL ke snížení vad kódu C/C++.

2. Desktopové programy windows vyžadují <windows.h>. Často také vidíte #include <tchar.h>. To usnadňuje vytváření aplikace, která může fungovat s char i wchar_t. Funguje to tak, že místo toho použijete TCHAR makro v kódu. TCHAR se vyhodnotí jako wchar_t, když váš projekt definuje symbol UNICODE; jinak se vyhodnotí jako char. Pokud vždy sestavujete se zapnutým UNICODE, nepotřebujete TCHAR a můžete rovnou použít wchar_t přímo. Další informace naleznete v tématu Použití mapování obecného textu. Následující kód ukazuje tyto dva #include příkazy v horní části souboru.

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

3. Spolu s funkcí WinMain musí mít každá desktopová aplikace Windows také funkci procedury okna. Tento postup označuje funkci jako WndProc, ale ve svém kódu ji můžete pojmenovat jakkoli chcete. WndProc má následující syntaxi.

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

   V této funkci napíšete kód pro zpracování zpráv , které aplikace obdrží z Windows, když dojde k událostem . Pokud například uživatel ve vaší aplikaci zvolí tlačítko OK, systém Windows vám pošle zprávu. Kód píšete uvnitř funkce WndProc, která provádí jakoukoli potřebnou práci. Označuje se jako zpracování události. Zpracováváte pouze události, které jsou relevantní pro vaši aplikaci.

   Další informace naleznete v tématu Procedury okna.

Přidat funkčnost do funkce WinMain

Před WinMaindeklarujte hodnoty a proceduru okna, které používají jiné části programu. Tyto deklarace se v úplném zdrojovém kódu objevují před WinMain:

// 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. WinMain Ve funkci potřebujete zachytit některé základní informace o hlavním okně. Uděláte to vyplněním struktury typu WNDCLASSEX. Struktura obsahuje informace o okně, například ikonu aplikace, barvu pozadí okna, název, který se má zobrazit v záhlaví, mimo jiné. Důležité je, že obsahuje ukazatel funkce na proceduru okna, která zpracovává zprávy, které Windows odesílá do vaší aplikace. Následující příklad ukazuje typickou WNDCLASSEX strukturu:

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

   Informace o polích této struktury naleznete v tématu WNDCLASSEX.

2. Jakmile strukturu vyplníte, zaregistrujte WNDCLASSEX ji v Windows, aby věděla o okně a o tom, jak do ní odesílat zprávy. RegisterClassEx Použijte funkci a předejte strukturu třídy okna jako argument. Makro _T zajistí, že literál řetězce odpovídá typu znaku vybranému pomocí TCHAR, jak je popsáno v předchozí diskusi o Unicode. Následující kód ukazuje, jak zaregistrovat třídu okna.

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

3. Vytvořte okno pomocí CreateWindowEx funkce.

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

   Tato funkce vrací HWND, což je popisovač okna. Úchyt je poněkud jako ukazatel. Systém Windows ho používá ke sledování vytvářených oken. Další informace naleznete v tématu Datové typy Systému Windows.

4. V tomto okamžiku se okno vytvořilo, ale přesto musíme windows říct, aby bylo viditelné. To je to, co tento kód dělá:

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

   Zobrazené okno je jenom prázdný obdélník, protože jste funkci ještě neimplementovali WndProc . Aplikace zatím nezachází se zprávami, které do ní systém Windows odesílá.

5. Abychom mohli zprávy zpracovat, nejprve přidáme to, čemu se říká smyčka zpráv, která naslouchá zprávám odesílaných systémem Windows. Když aplikace obdrží zprávu, tato smyčka ji odešle do vaší WndProc funkce, která se má zpracovat. Smyčka zprávy se podobá následujícímu kódu:

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

   Další informace o strukturách a funkcích ve smyčce zpráv naleznete v tématu MSG, , GetMessageTranslateMessage a DispatchMessage.

   Základní WinMain funkce, která vytvoří hlavní okno aplikace a naslouchá zprávám, které Windows odesílá vaši aplikaci, by vypadalo podobně jako následující kód:

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

Zpracování zpráv ve WndProc funkci

1. Ke zpracování zpráv, které aplikace přijímá, vložíte do funkce WndProc příkaz switch.

   Důležitá zpráva, která se má zpracovat, je WM_PAINT. Aplikace obdrží WM_PAINT zprávu, když musí být aktualizována část zobrazeného okna. K této události může dojít, když uživatel přesune okno před vaše okno a pak ho zase odsune. Tato zpráva se zobrazí při prvním zobrazení okna, takže máte možnost zobrazit uživatelské rozhraní aplikace. Aplikace o těchto událostech zjistí, když je Systém Windows odešle. Při prvním zobrazení okna je nutné aktualizovat všechna okna.

   Pokud chcete zpracovat WM_PAINT zprávu, nejprve zavolejte BeginPainta pak zpracujte veškerou logiku pro rozložení textu, tlačítek a dalších ovládacích prvků v okně. Pak zavolejte EndPaint. Pro tuto aplikaci kód mezi BeginPaint() a EndPaint() zobrazí Hello, Windows desktop! v okně, které jste vytvořili v WinMain(). V následujícím kódu TextOut funkce zobrazí text v zadaném umístění v okně.

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

   V předchozím kódu je HDC popisovač kontextu zařízení přidružený ke klientské oblasti okna. Při kreslení v okně použijte tento identifikátor k označení klientské oblasti. Pomocí funkcí BeginPaint a EndPaint se připravte na kreslení v klientské části okna a dokončete je. BeginPaint vrátí popisovač kontextu zařízení zobrazení používaného ke kreslení v klientské oblasti; EndPaint ukončí požadavek na vykreslení a uvolní kontext zařízení.

2. Aplikace obvykle zpracovává mnoho dalších zpráv. Odešle se například WM_CREATE při prvním vytvoření okna a WM_DESTROY při zavření okna. Následující kód ukazuje základní, ale úplnou WndProc funkci:

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

Sestavte kód

Jak jsme slíbili, kompletní kód pro pracovní aplikaci následuje.

Sestavení tohoto příkladu

1. Odstraňte veškerý kód v HelloWindowsDesktop.cpp editoru. Zkopírujte tento ukázkový kód a vložte ho do HelloWindowsDesktop.cpp:

   // 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. V nabídce Sestavení zvolte Sestavit řešení. Výsledky kompilace se zobrazí v okně Výstup v aplikaci Visual Studio.

   

   Animace ukazuje kliknutí na tlačítko Uložit vše a potom v hlavní nabídce zvolte Sestavit > Sestavit řešení.

3. Aplikaci spustíte stisknutím klávesy F5. Mělo by se zobrazit okno s textem Hello, Windows desktop! .

   

Gratulujeme! Vytvořili jste tradiční desktopovou aplikaci pro Windows.

Viz také

• Typy desktopových aplikací windows C++