Procedura dettagliata: Creare un'applicazione desktop di Windows tradizionale (C++)

Questa procedura dettagliata illustra come creare un'applicazione desktop di Windows tradizionale in Visual Studio. L'applicazione creata usa l'API Di Windows per visualizzare Hello, Windows Desktop! in una finestra. È possibile usare il codice sviluppato in questa procedura dettagliata come modello per creare applicazioni desktop di Windows.

L'API Windows (nota anche come API Win32, API Desktop di Windows e API classica di Windows) è un framework basato sul linguaggio C per la creazione di applicazioni Windows. È stato usato per creare applicazioni Windows per decenni. I framework più avanzati e più facili da programmare sono stati basati sull'API Windows, ad esempio I framework MFC, ATL e .NET. Anche il codice Windows Runtime più moderno per le app UWP e Store scritte in C++/WinRT usa l'API Windows sottostante. Per altre informazioni sull'API Windows, vedere Indice API Windows.

Prerequisiti

• Microsoft Windows 7 o versioni successive. Ti consigliamo Windows 11 o versione successiva per un'esperienza di sviluppo ottimale.

• Visual Studio. Per informazioni su come scaricare e installare Visual Studio, vedere Installare Visual Studio. Quando si esegue il programma di installazione, assicurarsi che sia selezionato il carico di lavoro Sviluppo di applicazioni desktop con C++. Non è un problema se il carico di lavoro non è stato installato durante l'installazione di Visual Studio. È possibile eseguire nuovamente il programma di installazione e installarlo ora.

  

• Conoscenza di base di come usare l'IDE di Visual Studio. Se si sono usate app desktop di Windows in precedenza, è probabilmente possibile riuscire a seguire. Per informazioni introduttive, vedere Panoramica delle funzionalità dell'IDE di Visual Studio.

• Familiarità con il linguaggio C++. Non preoccuparti, non facciamo nulla di troppo complicato.

Creare un progetto desktop di Windows

Seguire questa procedura per creare il primo progetto desktop di Windows. Non incollare i singoli estratti di codice man mano che si procede. Dopo aver creato il progetto, usare l'origine completa in Compilare il codice.

Per visualizzare i passaggi per la versione preferita di Visual Studio, usare il selettore della versione disponibile nella parte superiore del sommario in questa pagina.

Il codice

Informazioni su come creare il codice per un'applicazione desktop di Windows in Visual Studio.

Modalità di interazione del programma

Un'applicazione desktop Windows tradizionale usa diversi componenti di codice di installazione prima di poter visualizzare una finestra:

Gli estratti seguenti si concentrano su una parte del programma alla volta. L'origine completa combina le parti nell'ordine corretto.

Posizione in cui viene avviata l'esecuzione del codice in un'applicazione desktop di Windows

1. Come ogni applicazione C e applicazione C++ deve avere una main funzione come punto di partenza, ogni applicazione desktop di Windows deve avere una WinMain funzione. WinMain presenta la sintassi seguente.

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

   Per informazioni sui parametri e sul valore restituito di questa funzione, vedere Punto di ingresso WinMain.

   Nota

   Quali sono tutte quelle parole in più, come WINAPI, o CALLBACK, o HINSTANCE, o _In_? L'API di Windows tradizionale fa ampio uso di typedef e macro del preprocessore per astrarre certi dettagli relativi ai tipi e al codice specifico della piattaforma, come le convenzioni di chiamata, le dichiarazioni __declspec e le direttive pragma del compilatore. In Visual Studio è possibile usare la funzionalità Informazioni rapide di IntelliSense per vedere cosa definiscono questi typedef e macro. Passa il puntatore del mouse sulla parola di interesse oppure selezionala e premi Ctrl+K, CtrlI per visualizzare una piccola finestra a comparsa che contiene la definizione. Per altre informazioni, vedere Using IntelliSense. I parametri e i tipi restituiti dalle funzioni utilizzano spesso le annotazioni SAL per aiutarti a individuare errori di programmazione. Per altre informazioni, vedere Uso delle annotazioni SAL per ridurre i difetti del codice C/C++.

2. I programmi desktop di Windows richiedono <windows.h>. Vedi anche frequentemente #include <tchar.h>. Ciò semplifica la scrittura di un'app che può funzionare con char o wchar_t. Il modo in cui funziona è che invece si usa la TCHAR macro nel codice. TCHAR viene risolto in wchar_t quando il progetto definisce il UNICODE simbolo; in caso contrario, viene risolto in char. Se si compila sempre con UNICODE abilitato, non è necessario TCHAR e può essere usato wchar_t direttamente. Per ulteriori informazioni, consulta Utilizzare le mappature di testo generico. Il codice seguente mostra queste due #include istruzioni all'inizio del file.

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

3. Insieme alla WinMain funzione , ogni applicazione desktop di Windows deve avere anche una funzione window-procedure. Questa procedura dettagliata denomina la funzione WndProc, ma è possibile assegnargli il nome desiderato nel codice. WndProc presenta la sintassi seguente.

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

   In questa funzione si scrive codice per gestire i messaggi ricevuti dall'applicazione da Windows quando si verificano eventi . Ad esempio, se un utente sceglie un pulsante OK nell'applicazione, Windows invia un messaggio all'utente. È possibile scrivere codice all'interno di una WndProc funzione che esegue qualsiasi operazione appropriata. Si chiama gestire un evento. Si gestiscono solo gli eventi rilevanti per l'applicazione.

   Per altre informazioni, vedere Routine della finestra.

Aggiungere funzionalità alla WinMain funzione

Prima di WinMain, dichiarare i valori e la procedura della finestra usati da altre parti del programma. Queste dichiarazioni compaiono prima di WinMain nel codice sorgente completo:

// 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 Nella funzione è necessario acquisire alcune informazioni di base sulla finestra principale. Lo si fa compilando una struttura di tipo WNDCLASSEX. La struttura contiene informazioni sulla finestra, ad esempio l'icona dell'applicazione, il colore di sfondo della finestra, il nome da visualizzare nella barra del titolo, tra le altre cose. È importante notare che contiene un puntatore a funzione per la procedura di finestra che gestisce i messaggi che Windows invia alla tua app. L'esempio seguente mostra una struttura tipica 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);
   

   Per informazioni sui campi di questa struttura, vedere WNDCLASSEX.

2. Dopo aver compilato la WNDCLASSEX struttura, registrarla con Windows in modo che conosca la finestra e come inviare messaggi. Usare la funzione RegisterClassEx e passare la struttura della classe di finestra come argomento. La macro _T fa sì che il letterale di stringa corrisponda al tipo di carattere selezionato da TCHAR, come descritto in precedenza nella discussione su Unicode. Il codice seguente illustra come registrare la classe window.

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

3. Creare una finestra usando la CreateWindowEx funzione .

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

   Questa funzione restituisce un HWND, che è un identificatore di una finestra. Un handle è in qualche modo simile a un puntatore. Windows lo usa per tenere traccia delle finestre create. Per altre informazioni, vedere Tipi di dati Windows.

4. A questo punto, la finestra è stata creata, ma è comunque necessario indicare a Windows di renderla visibile. Ecco cosa fa questo codice:

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

   La finestra visualizzata è solo un rettangolo vuoto perché la funzione non è ancora stata implementata WndProc . L'applicazione non gestisce ancora i messaggi inviati da Windows.

5. Per gestire i messaggi, aggiungiamo prima di tutto ciò che viene chiamato ciclo di messaggi per ascoltare i messaggi inviati da Windows. Quando l'applicazione riceve un messaggio, questo ciclo lo invia alla WndProc funzione da gestire. Il ciclo di messaggi è simile al codice seguente:

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

   Per altre informazioni sulle strutture e le funzioni nel ciclo di messaggi, vedere MSG, GetMessageTranslateMessage e DispatchMessage.

   Una funzione di base WinMain che crea la finestra principale dell'applicazione e rimane in ascolto dei messaggi inviati da Windows, è simile al codice seguente:

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

Gestire i messaggi nella WndProc funzione

1. Per gestire i messaggi ricevuti dall'applicazione, implementare un'istruzione switch nella WndProc funzione.

   Un messaggio importante da gestire è WM_PAINT. L'applicazione riceve un WM_PAINT messaggio quando una parte della finestra visualizzata deve essere aggiornata. L'evento può verificarsi quando un utente sposta una finestra davanti alla finestra e la sposta nuovamente. Riceve questo messaggio la prima volta che viene visualizzata la finestra, offrendo la possibilità di visualizzare l'interfaccia utente dell'applicazione. L'applicazione rileva questi eventi quando Windows li invia. Quando la finestra viene visualizzata per la prima volta, è necessario aggiornarla.

   Per gestire un WM_PAINT messaggio, chiamare BeginPaintprima , quindi gestire tutta la logica per disporre il testo, i pulsanti e altri controlli nella finestra. Quindi chiamare EndPaint. In questa applicazione, il codice compreso tra BeginPaint() e EndPaint() visualizza Hello, Windows desktop! nella finestra creata in WinMain(). Nel codice seguente la TextOut funzione visualizza il testo nella posizione specificata nella finestra.

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

   Nel codice precedente è HDC un handle per un contesto di dispositivo associato all'area client della finestra. Quando si disegna nella finestra, usare questo handle per fare riferimento all'area client. Utilizzare le funzioni BeginPaint e EndPaint per preparare e completare il disegno nell'area client. BeginPaint restituisce un handle al contesto di dispositivo di visualizzazione utilizzato per il disegno nell'area client; EndPaint termina la richiesta paint e rilascia il contesto di dispositivo.

2. Un'applicazione gestisce in genere molti altri messaggi. Ad esempio, WM_CREATE viene inviato quando viene creata per la prima volta una finestra e WM_DESTROY quando la finestra viene chiusa. Il codice seguente illustra una funzione di base ma completa 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, 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;
   }
   

Compilare il codice

Come promesso, il codice completo per l'applicazione funzionante segue.

Per compilare questo esempio

1. Eliminare tutto il codice nell'editor HelloWindowsDesktop.cpp . Copiare questo codice di esempio e incollarlo in 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. Scegliere Compila soluzione dal menu Compila. I risultati della compilazione vengono visualizzati nella finestra Output di Visual Studio.

   

   L'animazione mostra come fare clic sul pulsante Salva tutto, quindi selezionare Compila > Compila soluzione dal menu principale.

3. Premere F5 per eseguire l'applicazione. Verrà visualizzata una finestra con il testo Hello, Windows desktop! .

   

Complimenti. È stata creata un'applicazione desktop di Windows tradizionale.

Vedi anche

• Tipi di applicazioni desktop Windows C++