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 nejnovější prostředí Windows Runtime kód pro aplikace pro UPW a Store napsané v jazyce C++/WinRT používá rozhraní API pro Windows pod ním. Další informace o rozhraní API systému Windows naleznete v tématu Index rozhraní API systému Windows.

Důležité

V části Sestavení kódu na konci tohoto článku se zobrazí úplný kód. Tento názorný postup popisuje různé části kódu, které se nacházejí v aplikaci pro Windows, ale některé podrobnosti jsou v fragmentech kódu vynechány, aby se zaměřily na nejdůležitější části. Kompletní kód můžete zkopírovat a vložit ho do projektu na konci.

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škrtnuto vývoj desktopových aplikací s úlohou 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. Jak je uvedeno na začátku tohoto článku, dokončený kód je k dispozici v části Sestavení kódu na konci návodu. Pokračujte a postupujte podle kroků k vytvoření projektu, ale až do konce vydržte vložení následujících částí kódu, až se zobrazí kompletní kód aplikace. Některé podrobnosti se v fragmentech kódu vynechávají, aby se zaměřily na nejdůležitější části. Kompletní kód můžete zkopírovat a vložit ho do projektu na konci.

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). Vzhledem k tomu, že vytváříme aplikaci pro Windows, výsledkem výběru konzolové aplikace bude projekt, který nebude sestavovat s ohledem na kód, který použijeme. 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ík řešení, výběr možnosti Přidat v nabídce, která se zobrazí, a pak zvolte 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.

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 WinMain vstupní bod.

   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, + pro malé automaticky otevírané 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 psaní aplikace, která může pracovat s aplikací char nebo wchar_t. Funguje to tak, že místo toho použijete TCHAR makro v kódu, které se nakonec přeloží na wchar_t to, jestli UNICODE je symbol definovaný v projektu, jinak se přeloží na char. Pokud vždy vytváříte s povoleným kódováním UNICODE, nepotřebujete TCHAR a můžete je používat 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. Tato funkce se nazývá WndProc, ale můžete jí dát jakýkoli název, který se vám v kódu líbí. 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 napíšete uvnitř WndProc funkce, která dělá cokoli, co je vhodné. 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řidání funkcí do WinMain funkce

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, zaregistrujete WNDCLASSEX ji ve 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 se používá, protože používáme TCHAR typ podle předchozí diskuze o kódování 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.

   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, height)
   // 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;
   }
   

   Tato funkce vrátí HWNDpopisovač 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 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;
      }
   
      // 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 obdrží, implementujete switch ve své WndProc funkci příkaz.

   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. Událost může nastat, když uživatel přesune okno před okno a znovu ho přesune. 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 se kód mezi BeginPaint() a EndPaint() zobrazí Hello, Windows desktop! v okně, ve které jste vytvořili .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, _tcslen(greeting));
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   V předchozím kódu HDC je popisovač kontextu zařízení, který je přidružený k klientské oblasti okna. Použijete ho při kreslení v okně k odkazování na jeho klientskou oblast. Pomocí funkcí BeginPaint se EndPaint připravte na výkres v klientské oblasti a dokončete ho. BeginPaint vrátí popisovač kontextu zobrazovacího zařízení použitého pro kreslení v klientské oblasti; EndPaint ukončí žádost o malování 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, _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;
   }
   

Sestavení kódu

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 <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, height)
      // 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;
      }
   
      // 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, _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. V nabídce Sestavení zvolte Sestavit řešení. Výsledky kompilace se zobrazí v okně Výstup v sadě 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++