Útmutató: Hagyományos asztali Windows-alkalmazás létrehozása (C++)

Ez az útmutató bemutatja, hogyan hozhat létre hagyományos windowsos asztali alkalmazást a Visual Studióban. A létrehozott alkalmazás a Windows API használatával jeleníti meg a Hello, Windows desktop! alkalmazást egy ablakban. Az ebben az útmutatóban létrehozott kódot mintaként használhatja windowsos asztali alkalmazások létrehozásához.

A Windows API (más néven Win32 API, Windows Desktop API és Klasszikus Windows API) egy C nyelvalapú keretrendszer a Windows-alkalmazások létrehozásához. Évtizedek óta használják Windows-alkalmazások létrehozására. A fejlettebb és könnyebben programozott keretrendszerek a Windows API-ra épülnek, például az MFC, az ATL és a .NET-keretrendszerekre. Még a C++/WinRT nyelven írt UWP- és Store-alkalmazások legmodernebb Windows-futtatókörnyezeti kódja is a Windows API-t használja. A Windows API-val kapcsolatos további információkért lásd a Windows API Indexet.

Fontos

A cikk végén található Kód összeállítása szakasz a teljes kódot jeleníti meg. Ez az útmutató a Windows-alkalmazásokba bejárt különböző kódrészleteket ismerteti, de a kódrészletekben kihagyunk néhány részletet, hogy a legfontosabb részekre összpontosítsunk. A teljes kódot átmásolhatja, és beillesztheti a projektbe a végén.

Előfeltételek

• Microsoft Windows 7 vagy újabb verziók. A legjobb fejlesztési élmény érdekében a Windows 11-et vagy újabb verziót javasoljuk.

• Visual Studio. A Visual Studio letöltéséről és telepítéséről további információt a Visual Studio telepítése című témakörben talál. A telepítő futtatásakor győződjön meg arról, hogy a C++ számítási feladattal rendelkező asztali fejlesztés be van jelölve. Ne aggódjon, ha nem telepítette ezt a számítási feladatot a Visual Studio telepítésekor. A telepítőt újra futtathatja, és most telepítheti.

  

• A Visual Studio IDE használatának alapszintű ismerete. Ha korábban már használt asztali Windows-alkalmazásokat, valószínűleg lépést tarthat. Bevezetésként tekintse meg a Visual Studio IDE funkcióbemutatóját.

• A C++ nyelv ismerete. Ne aggódj, nem csinálunk túl bonyolultat.

Asztali Windows-projekt létrehozása

Kövesse az alábbi lépéseket az első asztali Windows-projekt létrehozásához. Ahogy a cikk elején említettük, a kész kód az útmutató végén, a Kód összeállítása szakaszban érhető el. Folytassa, és kövesse a projekt létrehozásához szükséges lépéseket, de halassza el a következő kódszakaszok beillesztését a teljes alkalmazáskód bemutatásáig. A kódrészletek néhány részletet kihagynak, hogy a legfontosabb részekre összpontosítsanak. A teljes kódot átmásolhatja, és beillesztheti a projektbe a végén.

A Visual Studio előnyben részesített verziójának lépéseinek megtekintéséhez használja az oldal tartalomjegyzékének tetején található Verzióválasztót .

Asztali Windows-projekt létrehozása a Visual Studióban

1. A főmenüBen válassza azÚj>projekt> lehetőséget az Új projekt létrehozása párbeszédpanel megnyitásához.

2. A párbeszédpanel tetején állítsa a Language (Nyelv ) elemet C++-ra, állítsa a PlatformotWindowsra, és állítsa a Project típusátAsztalira.

3. A projekttípusok szűrt listájában válassza a Windows Asztali varázslót , majd a Tovább gombot. A következő lapon adja meg a projekt nevét, például a DesktopAppot.

4. A projekt létrehozásához válassza a Létrehozás gombot.

5. Ekkor megjelenik a Windows Desktop Project párbeszédpanel. Az Alkalmazástípus legördülő listában válassza az Asztali alkalmazás (.exe) lehetőséget. Mivel Windows-alkalmazást készítünk, a Konzolalkalmazás kiválasztása olyan projektet eredményez, amely nem fog létrejönni a használni kívánt kód alapján. Ezután a További beállítások csoportban válassza az Üres projekt lehetőséget. Válassza az OK gombot a projekt létrehozásához.

6. A Megoldáskezelőben kattintson a jobb gombbal a DesktopApp projektre, válassza a Hozzáadás, majd az Új elem lehetőséget.

   

   Az animációban a jobb gombbal a projekt nevére kattint a Megoldáskezelőben, majd a megjelenő menüBen a Hozzáadás, majd az Új elem lehetőséget választja.

7. Az Új elem hozzáadása párbeszédpanelen válassza a C++ fájl (.cpp) lehetőséget. A Név mezőbe írja be például a fájl HelloWindowsDesktop.cppnevét. Válassza a elemet, adja hozzá aelemet.

   

Ekkor létrejön a projekt, és megnyílik a forrásfájl a szerkesztőben.

A kód

Ezután megtudhatja, hogyan hozhatja létre a kódot asztali Windows-alkalmazásokhoz a Visual Studióban.

A kód futásának helye asztali Windows-alkalmazásban

1. Ahogyan minden C és C++ alkalmazásnak rendelkeznie kell egy main függvénnyel kiindulási pontként, minden asztali Windows-alkalmazásnak rendelkeznie kell egy WinMain függvénnyel. WinMain szintaxisa az alábbi.

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

   A függvény paramétereiről és visszatérési értékéről további információt a WinMain belépési pontban talál.

   Megjegyzés:

   Mik azok a plusz szavak, például WINAPI, vagy CALLBACK, vagy HINSTANCE, vagy _In_? A hagyományos Windows API széles körben használja a typedef-eket és az előprocesszoros makrókat, hogy absztrahálja a típusok és a platformspecifikus kódok egyes részleteit, mint például a hívási konvenciók, a deklarációk és a fordítópragmák. A Visual Studióban az IntelliSense gyorsinformációs funkciójával megtekintheti, hogy ezek a típusdefek és makrók mit határoznak meg. Vigye az egérmutatót a kívánt szó fölé, vagy jelölje ki, majd nyomja le a Ctrl+K, CtrlI+ egy kis előugró ablakhoz, amely tartalmazza a definíciót. További információ: Az IntelliSense használata. A paraméterek és a visszatérési típusok gyakran használnak SAL-széljegyzeteket a programozási hibák elhárításához. További információ: A C/C++ kódhibák csökkentése SAL-széljegyzetek használatával.

2. A Windows asztali programokhoz szükséges <windows.h>. Gyakran megjelenik #include <tchar.h>az is. Ez megkönnyíti egy olyan alkalmazás írását, amely együtt tud működni akár a char vagy a wchar_t elemmel. A működési elv az, hogy a kódban a TCHAR makrót használja, amely végső soron wchar_t-re oldódik fel, ha a UNICODE szimbólum definiálva van a projektben, különben char-ra. Ha mindig _UNICODE_-szal építed a programot, akkor nincs szükség TCHAR-re, és közvetlenül használhatod wchar_t-et. További információ: Általános szövegleképezések használata. Az alábbi kód ezt a két #include utasítást mutatja a fájl tetején.

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

3. A függvény mellett WinMain minden asztali Windows-alkalmazásnak rendelkeznie kell egy ablakeljárási függvénnyel is. Ezt a függvényt nevezik egynek WndProc, de bármilyen nevet megadhat a kódban. WndProc szintaxisa az alábbi.

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

   Ebben a függvényben olyan kódot ír, amely kezeli azokat az üzeneteket , amelyeket az alkalmazás a Windowsból fogad események bekövetkezésekor. Ha például egy felhasználó egy OK gombot választ az alkalmazásban, a Windows üzenetet küld Önnek. Ön egy olyan függvénybe ír kódot, amely elvégzi a szükséges feladatokat. Eseménykezelésnek hívják. Csak az alkalmazás szempontjából releváns eseményeket kezeli.

   További információ az ablakkezelési eljárásokról a alatt található.

Funkciók hozzáadása a WinMain függvényhez

1. A függvényben WinMain rögzítenie kell néhány alapvető információt a főablakról. Ezt egy típus WNDCLASSEXszerkezetének kitöltésével teheti meg. A struktúra többek között információkat tartalmaz az ablakról, például az alkalmazás ikonjáról, az ablak háttérszínéről, a címsorban megjelenítendő névről. Fontos, hogy tartalmaz egy függvénymutatót az ablak eljárásához, amely kezeli a Windows által az alkalmazásnak küldött üzeneteket. Az alábbi példa egy tipikus WNDCLASSEX struktúrát mutat be:

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

   A struktúra mezőivel kapcsolatos információkért lásd: WNDCLASSEX.

2. Miután kitöltötte a WNDCLASSEX struktúrát, regisztrálja a Windowsban, hogy tudjon az ablakról, és hogy hogyan küldhet neki üzeneteket. Használja a függvényt, RegisterClassEx és adja át az ablakosztály szerkezetét argumentumként. A _T makrót azért használja a rendszer, mert a TCHAR Unicode-ról szóló előző vitafórumban használt típust használjuk. Az alábbi kód bemutatja, hogyan regisztrálhatja az ablakosztályt.

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

3. Hozzon létre egy ablakot a CreateWindowEx függvény használatával.

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

   Ez a függvény egy HWND, egy ablakhoz tartozó fogópontot ad vissza. A fogópont kissé olyan, mint egy mutató. A Windows ezzel nyomon követi a létrehozott ablakokat. További információ: Windows-adattípusok.

4. Ezen a ponton létrejött az ablak, de továbbra is meg kell adnunk a Windowsnak, hogy láthatóvá tegye. Ezt csinálja ez a kód:

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

   A megjelenített ablak csak egy üres téglalap, mert még nem implementálta a függvényt WndProc . Az alkalmazás még nem kezeli azokat az üzeneteket, amelyeket a Windows most küld neki.

5. Az üzenetek kezeléséhez először hozzáadjuk az úgynevezett üzenethurkot , hogy figyeljük a Windows által küldött üzeneteket. Amikor az alkalmazás üzenetet kap, ez a hurok küldi el a WndProc kezelendő függvénynek. Az üzenethurok a következő kódhoz hasonlít:

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

   Az üzenethurok struktúráiról és funkcióiról további információt a következő témakörben találMSG: , GetMessageTranslateMessage és DispatchMessage.

   Az alkalmazás főablakát létrehozó és a Windows által az alkalmazást küldő üzeneteket figyelő alapfüggvény WinMain a következő kódhoz hasonló:

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

Üzenetek kezelése a WndProc függvényben

1. Az alkalmazás által kapott üzenetek kezeléséhez egy utasítást switch kell implementálnia a WndProc függvényben.

   Egy fontos üzenet, amelyet kezelni kell: WM_PAINT. Az alkalmazás üzenetet WM_PAINT kap, ha a megjelenített ablak egy részét frissíteni kell. Az esemény akkor fordulhat elő, ha egy felhasználó áthelyez egy ablakot az ablak elé, és ismét áthelyezi. Ezt az üzenetet az ablak első megjelenésekor kapja meg, így lehetősége van az alkalmazás felhasználói felületének megjelenítésére. Az alkalmazás akkor értesül ezekről az eseményekről, amikor a Windows értesítést küld róluk. Az ablak első megjelenésekor az összeset frissíteni kell.

   Egy WM_PAINT üzenet kezeléséhez először hívja fel BeginPaint, majd kezelje az összes logikát a szöveg, a gombok és az ablak egyéb vezérlőinek elrendezéséhez. Ezután hívja meg EndPaint. Ebben az alkalmazásban a kód a BeginPaint() és EndPaint() között Hello, Windows desktop!-t jelenít meg az Ön által létrehozott WinMain() ablakban. A következő kódban a függvény megjeleníti TextOut a szöveget az ablakban megadott helyen.

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

   Az előző kódban a HDC egy eszközkörnyezet leírója, amely az ablak ügyfélterületéhez van társítva. Az ablakban rajzolva hivatkozhat az ügyfélterületére. Használja a BeginPaint és EndPaint függvényeket az ügyfélterület rajzának előkészítéséhez és befejezéséhez. BeginPaint egy hivatkozást ad vissza a kliens területén való rajzoláshoz használt kijelző eszközkörnyezethez; EndPaint befejezi a kirajzolási kérést, és felszabadítja az eszközkörnyezetet.

2. Az alkalmazások általában sok más üzenetet kezelnek. A rendszer például WM_CREATE az ablak első létrehozásakor és WM_DESTROY az ablak bezárásakor küldi el. Az alábbi kód egy egyszerű, de teljes WndProc függvényt mutat be:

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

A kód létrehozása

Ahogy ígértük, a munkaalkalmazás teljes kódja a következő.

A példa létrehozása

1. Törölje az összes kódot a szerkesztőben HelloWindowsDesktop.cpp . Másolja ki ezt a példakódot, és illessze be a következőbe 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. A Build menüben válassza a Megoldás létrehozása lehetőséget. A fordítás eredményei a Visual Studióban a Kimenet ablakban jelennek meg.

   

   Az animáció azt mutatja, hogy az Összes mentése gombra kattint, majd a főmenüben a Build > Megoldás létrehozása menüpontot választja.

3. Az alkalmazás futtatásához nyomja le az F5 billentyűt. Ekkor megjelenik egy ablak a szöveggel Hello, Windows desktop! .

   

Gratulálok! Egy hagyományos Windows asztali alkalmazást készített.

Lásd még

• Windows C++ asztali alkalmazástípusok