Esercitazione: Creare progetti multipiattaforma C++ in Visual Studio

2025-04-16

Lo sviluppo di Visual Studio C e C++ non è più per Windows. Questa esercitazione illustra come usare lo sviluppo multipiattaforma di Visual Studio per C++ in Windows e Linux. Si basa su CMake, quindi non è necessario creare o generare progetti di Visual Studio. Quando si apre una cartella contenente un file CMakeLists.txt, Visual Studio configura automaticamente le impostazioni di IntelliSense e di compilazione. È possibile avviare rapidamente la modifica, la compilazione e il debug del codice in locale in Windows. Passare quindi alla configurazione per eseguire la stessa operazione in Linux, tutto dall'interno di Visual Studio.

In questa esercitazione si apprenderà come:

clonare un progetto CMake open source da GitHub
aprire il progetto in Visual Studio
compilare ed eseguire il debug di una destinazione eseguibile in Windows
aggiungere una connessione a un computer Linux
compilare ed eseguire il debug della stessa destinazione in Linux

Prerequisiti

Configurare Visual Studio per lo sviluppo C++ multipiattaforma
- Prima di tutto, installare Visual Studio e scegliere lo sviluppo di applicazioni desktop con C++ e Linux con carichi di lavoro C++. Questa installazione minima è di soli 3 GB. A seconda della velocità di download, l'installazione non dovrebbe richiedere più di 10 minuti.
Configurare un computer Linux per lo sviluppo C++ multipiattaforma
- Visual Studio non richiede alcuna distribuzione specifica di Linux. Il sistema operativo può essere in esecuzione in un computer fisico, in una macchina virtuale o nel cloud. È anche possibile usare il sottosistema Windows per Linux (WSL). Tuttavia, per questa esercitazione è necessario un ambiente grafico. WSL non è consigliato perché è destinato principalmente alle operazioni della riga di comando.
- Visual Studio richiede questi strumenti nel computer Linux: compilatori C++, gdb, sshrsync, make, e zip. Nei sistemi basati su Debian è possibile usare questo comando per installare queste dipendenze:
```
sudo apt install -y openssh-server build-essential gdb rsync make zip
```
- Visual Studio richiede una versione recente di CMake nel computer Linux con la modalità server abilitata (almeno 3.8). Microsoft produce una build universale di CMake che è possibile installare in qualsiasi distribuzione Linux. È consigliabile usare questa build per assicurarsi di avere le funzionalità più recenti. È possibile ottenere i file binari CMake dal fork Microsoft del repository CMake in GitHub. Passare a tale pagina e scaricare la versione corrispondente all'architettura di sistema nel computer Linux, quindi contrassegnarla come eseguibile:
```
wget <path to binary>
chmod +x cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh
```
- È possibile visualizzare le opzioni per l'esecuzione dello script con --help. È consigliabile usare l'opzione -prefix per specificare l'installazione nel percorso /usr , perché /usr/bin è il percorso predefinito in cui Visual Studio cerca CMake. L'esempio seguente illustra lo script linux-x86_64. Modificarlo in base alle esigenze se si usa una piattaforma di destinazione diversa.
```
sudo ./cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh --skip-license --prefix=/usr
```
Git per Windows è installato sul tuo computer Windows.
Un account GitHub.

Clonare un progetto CMake open source da GitHub

Questa esercitazione usa Bullet Physics SDK in GitHub. Fornisce simulazioni di rilevamento delle collisioni e fisica per molte applicazioni. L'SDK include programmi eseguibili di esempio che compilano ed eseguono senza dover scrivere altro codice. Questa esercitazione non modifica alcun codice sorgente o script di compilazione. Per iniziare, clonare il repository bullet3 da GitHub nel computer in cui è installato Visual Studio.

git clone https://github.com/bulletphysics/bullet3.git

Nel menu principale di Visual Studio scegliere File > Apri > CMake. Vai al file CMakeLists.txt nella directory principale del repository bullet3 che hai scaricato.

Non appena si apre la cartella, la struttura di cartelle diventa visibile in Esplora soluzioni.

Questa vista mostra esattamente ciò che si trova su disco, non una visualizzazione logica o filtrata. Per impostazione predefinita, non mostra i file nascosti.
Scegliere il pulsante Mostra tutti i file per visualizzare tutti i file nella cartella.

Passare alla visualizzazione destinazioni

Quando si apre una cartella che usa CMake, Visual Studio genera automaticamente la cache CMake. Questa operazione potrebbe richiedere alcuni istanti, a seconda delle dimensioni del progetto.

Nella finestra di output selezionare Mostra output da e quindi scegliere CMake per monitorare lo stato del processo di generazione della cache. Al termine dell'operazione, viene visualizzato il messaggio "Estrazione di informazioni di destinazione completata".

Al termine dell'operazione, IntelliSense è configurato. È possibile compilare il progetto ed eseguire il debug dell'applicazione. Visual Studio mostra ora una visualizzazione logica della soluzione, in base alle destinazioni specificate nei file CMakeLists.
Usare il pulsante Soluzioni e cartelle in Esplora soluzioni per passare alla visualizzazione Destinazioni CMake.

$Schermata del pulsante Soluzioni e cartelle in Esplora soluzioni. Mostra un menu a tendina con una scelta per c:\projects\bullet3 e un'altra scelta per la vista Destinazioni CMake, selezionata.$

Ecco l'aspetto di questa visualizzazione per Bullet SDK:

La visualizzazione Destinazioni offre una visualizzazione più intuitiva di ciò che si trova in questa base di origine. Alcuni obiettivi sono librerie e altri sono eseguibili.
Espandere un nodo nella visualizzazione Destinazioni CMake per visualizzare i relativi file di codice sorgente, ovunque questi file si trovino su disco.

Aggiungere una configurazione esplicita di Windows x64-Debug

Visual Studio crea una configurazione x64-Debug predefinita per Windows. Le configurazioni sono il modo in cui Visual Studio comprende quale piattaforma verrà usata per CMake. La configurazione predefinita non è rappresentata su disco. Quando si aggiunge in modo esplicito una configurazione, Visual Studio crea un file denominato CMakeSettings.json. Viene popolato con le impostazioni per tutte le configurazioni specificate.

Aggiungere una nuova configurazione. Aprire l'elenco a discesa Configurazione sulla barra degli strumenti e selezionare Gestisci configurazioni.

Verrà aperto l'editor delle impostazioni di CMake . Selezionare il segno più verde sul lato sinistro dell'editor per aggiungere una nuova configurazione. Viene visualizzata la finestra di dialogo Aggiungi configurazione a CMakeSettings :

Questa finestra di dialogo mostra tutte le configurazioni incluse in Visual Studio, oltre a tutte le configurazioni personalizzate create. Se si vuole continuare a usare una configurazione x64-Debug che deve essere la prima aggiunta. Selezionare x64-Debug e quindi scegliere il pulsante Seleziona . Visual Studio crea il file CMakeSettings.json con una configurazione per x64-Debug e lo salva su disco. È possibile usare i nomi desiderati per le configurazioni modificando il parametro name direttamente in CMakeSettings.json.

Impostare un punto di interruzione, compilare ed eseguire in Windows

In questo passaggio viene sottoposto a debug un programma di esempio che illustra la libreria Bullet Physics.

In Esplora soluzioni selezionare AppBasicExampleGui ed espanderlo.
Aprire il file BasicExample.cpp.
Impostare un punto di interruzione che viene raggiunto quando si fa clic nell'applicazione in esecuzione. L'evento Click viene gestito all'interno di un metodo all'interno di una classe di supporto. Per arrivare rapidamente:
1. Selezionare CommonRigidBodyBase da cui la struttura BasicExample è derivata. È intorno alla linea 30.
2. Fare clic con il pulsante destro del mouse e scegliere Vai a definizione. Ora si è nell'intestazione CommonRigidBodyBase.h.
3. Nella visualizzazione del browser sopra l'origine, dovresti vedere che sei in CommonRigidBodyBase. A destra, è possibile selezionare i membri da esaminare. Aprire l'elenco a discesa e selezionare mouseButtonCallback per passare alla definizione di tale funzione nell'intestazione.
Posizionare un punto di interruzione sulla prima riga all'interno di questa funzione. Viene raggiunto quando si fa clic su un pulsante del mouse all'interno della finestra dell'applicazione, quando viene eseguito nel debugger di Visual Studio.
Per avviare l'applicazione, selezionare l'elenco a discesa di avvio nella barra degli strumenti. È quello con l'icona di riproduzione verde che dice "Seleziona elemento di avvio". Nel menu a tendina selezionare AppBasicExampleGui.exe. Il nome eseguibile ora viene visualizzato sul pulsante di avvio:
Scegliere il pulsante di avvio per compilare l'applicazione e le dipendenze necessarie, quindi avviarla con il debugger di Visual Studio collegato. Dopo alcuni istanti, viene visualizzata l'applicazione in esecuzione:
Spostare il mouse nella finestra dell'applicazione, quindi fare clic su un pulsante per attivare il punto di interruzione. Il punto di interruzione riporta Visual Studio in primo piano e l'editor mostra la riga in cui viene sospesa l'esecuzione. È possibile esaminare le variabili dell'applicazione, gli oggetti, i thread e la memoria oppure esaminare il codice in modo interattivo. Scegliere Continua per consentire la ripresa dell'applicazione e quindi chiuderla normalmente. In alternativa, interrompere l'esecuzione all'interno di Visual Studio usando il pulsante di arresto.

Aggiungere una configurazione Linux e connettersi al computer remoto

Aggiungere una configurazione linux. Fare clic con il pulsante destro del mouse sul file CMakeSettings.json nella visualizzazione Esplora soluzioni e scegliere Aggiungi configurazione. Viene visualizzata la stessa finestra di dialogo Aggiungi configurazione a CMakeSettings come in precedenza. Selezionare Linux-Debug questa volta, quindi salvare il file CMakeSettings.json (CTRL+s).
Visual Studio 2019 versione 16.6 o successiva Scorrere verso il basso fino alla fine dell'editor delle impostazioni di CMake e selezionare Mostra impostazioni avanzate. Selezionare Makefile Unix come generatore CMake, quindi salvare il file CMakeSettings.json (CTRL+s).
Selezionare Linux-Debug nell'elenco a discesa della configurazione.

Se è la prima volta che ci si connette a un sistema Linux, viene visualizzata la finestra di dialogo Connetti al sistema remoto .

La finestra di dialogo contiene campi per il nome host, la porta, il nome utente, il tipo di autenticazione e la password. Tutti i campi sono vuoti, ad eccezione di Port è impostato su 22 e il tipo di autenticazione è impostato su Password.

Se è già stata aggiunta una connessione remota, è possibile aprire questa finestra passando a Strumenti > Opzioni > gestione connessione multipiattaforma>.
Specificare le informazioni di connessione al computer Linux e scegliere Connetti. Visual Studio aggiunge tale macchina a CMakeSettings.json come connessione predefinita per Linux-Debug. Estrae anche i header dal computer remoto, in modo da ottenere IntelliSense specifico per tale connessione remota. Visual Studio invia quindi i file al computer remoto e genera la cache CMake nel sistema remoto. Questi passaggi potrebbero richiedere del tempo, a seconda della velocità della rete e della potenza del computer remoto. Si sa che è completo quando viene visualizzato il messaggio "Estrazione informazioni di destinazione completata" nella finestra di output di CMake.

Impostare un punto di interruzione, compilare ed eseguire in Linux

Poiché si tratta di un'applicazione desktop, è necessario fornire altre informazioni di configurazione alla configurazione di debug.

Nella visualizzazione Destinazioni CMake fare clic con il pulsante destro del mouse su AppBasicExampleGui e scegliere Impostazioni di debug e avvio per aprire il file launch.vs.json presente nella sottocartella .vs nascosta. Questo file è locale per l'ambiente di sviluppo. È possibile spostarlo alla radice del progetto se si desidera controllarlo e salvarlo con il team. In questo file è stata aggiunta una configurazione per AppBasicExampleGui. Queste impostazioni predefinite funzionano nella maggior parte dei casi, ma non qui. Poiché si tratta di un'applicazione desktop, è necessario fornire alcune informazioni aggiuntive per avviare il programma in modo da poterlo visualizzare nel computer Linux.
Per trovare il valore della variabile DISPLAY di ambiente nel computer Linux, eseguire questo comando:
```
echo $DISPLAY
```
Nella configurazione per AppBasicExampleGui è presente una matrice di parametri, "pipeArgs". Contiene una riga: "${debuggerCommand}". Si tratta del comando che viene avviato gdb nel computer remoto. Prima dell'esecuzione del comando, Visual Studio deve esportare la visualizzazione in questo contesto. Ad esempio, se il valore della visualizzazione è :1, modificare tale riga come indicato di seguito:
```
"export DISPLAY=:1;${debuggerCommand}",
```
Avviare ed eseguire il debug dell'applicazione. Aprire l'elenco a discesa Seleziona elemento di avvio sulla barra degli strumenti e scegliere AppBasicExampleGui. Scegliere quindi l'icona di riproduzione verde sulla barra degli strumenti oppure premere F5. L'applicazione e le relative dipendenze sono basate sul computer Linux remoto, quindi avviate con il debugger di Visual Studio collegato. Nel computer Linux remoto dovrebbe essere visualizzata una finestra dell'applicazione.
Spostare il mouse nella finestra dell'applicazione e fare clic su un pulsante. Il punto di interruzione è stato raggiunto. L'esecuzione del programma viene sospesa, Visual Studio torna in primo piano e viene visualizzato il punto di interruzione. Verrà visualizzata anche una finestra della console Linux in Visual Studio. La finestra fornisce l'output dal computer Linux remoto e può anche accettare l'input per stdin. Come qualsiasi finestra di Visual Studio, è possibile ancorarla dove si preferisce visualizzarla. La sua posizione viene mantenuta nelle sessioni future.

L'output nella finestra indica che le funzioni C11 caricate dinamicamente usando dlopen/dlsym sono OK, è stato creato un contesto GL 3.0 e il contesto di rendering Direct GLX ottenuto e reso corrente. La finestra include varie informazioni sulla versione per GL_VENDOR, GL_VERSION, GL_SHADING_LANGUAGE_VERSION e così via.
È possibile esaminare le variabili dell'applicazione, gli oggetti, i thread, la memoria e esaminare il codice in modo interattivo usando Visual Studio. Questa volta, tuttavia, si esegue tutto in un computer Linux remoto anziché nell'ambiente Windows locale. È possibile scegliere Continua per consentire all'applicazione di riprendere e uscire normalmente oppure scegliere il pulsante di arresto, come con l'esecuzione locale.
Esaminare la finestra Stack di chiamate e visualizzare le chiamate a x11OpenGLWindow da quando Visual Studio ha avviato l'applicazione in Linux.

Lo stack di chiamate mostra il breakpoint in CommonRigidBodyBase::mouseMoveCallback e le chiamate che lo precedono, come OnMouseMove, X11OpenGLWindow::pumpMessage e così via.

Che cosa si è appreso

In questa esercitazione è stata clonata una codebase direttamente da GitHub. È stato creato, eseguito e sottoposto a debug in Windows senza modifiche. È stata quindi usata la stessa codebase, con modifiche di configurazione secondarie, per compilare, eseguire ed eseguire il debug in un computer Linux remoto.

Passaggi successivi

Altre informazioni sulla configurazione e il debug di progetti CMake in Visual Studio:

Progetti CMake in Visual Studio

Configurare un progetto CMake per Linux

Connettersi al computer Linux remoto

Personalizzare le impostazioni di compilazione di CMake

Configurare le sessioni di debug di CMake

Distribuire, eseguire e sottoporre a debug il progetto Linux

Riferimento alla configurazione predefinita CMake vcpkg nei progetti CMake Installare e usare pacchetti con CMake in Visual Studio