Esercitazione: Creare progetti multipiattaforma C++ in Visual Studio

Articolo
10/18/2023

Lo sviluppo C e C++ di Visual Studio non è più limitato a 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 apprenderai a:

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 di CMake dalla 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 nel 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. Passare al CMakeLists.txt file nella radice del repository bullet3 scaricato.

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

Questa visualizzazione mostra esattamente gli elementi presenti nel disco. Non si tratta di una visualizzazione logica o filtrata. Per impostazione predefinita, la visualizzazione non mostra i file nascosti.
Scegliere il pulsante Mostra tutti i file per visualizzare tutti i file nella cartella.

Passare alla visualizzazione delle destinazioni

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

Nella finestra di output selezionare Mostra output di 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 delle destinazioni CMake.

$Screenshot of the Solutions and Folders button in the Solution Explorer. It is selected, showing a dropdown with a choice for c:\projects\bullet3 and another choice for CMake Targets View, which is selected.$

Ecco l'aspetto di questa visualizzazione per Bullet SDK:

La visualizzazione delle destinazioni offre una visualizzazione più intuitiva del contenuto della base di origine. È possibile osservare che alcune destinazioni sono librerie e altri sono file eseguibili.
Espandere un nodo nella visualizzazione delle destinazioni CMake per visualizzare i file del codice sorgente, indipendentemente dal percorso dei file nel disco.

Aggiungere una configurazione x64-Debug Windows esplicita

Visual Studio crea una configurazione x64-Debug predefinita per Windows. Le configurazioni indicano a Visual Studio la piattaforma di destinazione da usare per CMake. La configurazione predefinita non è rappresentata nel disco. Quando si aggiunge in modo esplicito una configurazione, Visual Studio crea un file denominato CMake Impostazioni.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 Impostazioni 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 CMake Impostazioni:

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 CMake Impostazioni.json con una configurazione per x64-Debug e lo salva su disco. È possibile impostare il nome desiderato 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.
Apri il file BasicExample.cpp.
Impostare un punto di interruzione che viene raggiunto quando si fa clic nell'applicazione in esecuzione. L'evento Click è gestito in un metodo all'interno di una classe helper. Per passare rapidamente al punto specifico:
1. Selezionare CommonRigidBodyBase che lo struct BasicExample sia derivato da . È 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 si noterà che si è 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.
Inserire un punto di interruzione nella prima riga all'interno della 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 indica "Seleziona elemento di avvio". Nell'elenco a discesa selezionare AppBasicExampleGui.exe. Il nome dell'eseguibile è ora visibile 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 puntatore del 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 in Esplora soluzioni e selezionare Aggiungi configurazione. Viene visualizzata la finestra di dialogo Aggiungi configurazione a CMakeSettings descritta in precedenza. Selezionare Linux-Debug questa volta, quindi salvare il file CMake Impostazioni.json (CTRL+s).
Visual Studio 2019 versione 16.6 o successiva Scorrere verso il basso fino alla fine di CMake Impostazioni Editor e selezionare Mostra impostazioni avanzate. Selezionare Makefile Unix come generatore CMake, quindi salvare il file CMake Impostazioni.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 Connessione 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 > multipiattaforma > Gestione connessioni.
Specificare le informazioni di connessione al computer Linux e scegliere Connessione. Visual Studio aggiunge tale computer a CMake Impostazioni.json come connessione predefinita per Linux-Debug. Estrae anche le intestazioni 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 Debug e avvia Impostazioni per aprire il file launch.vs.json presente nella sottocartella .vs nascosta. Il file è un file locale dell'ambiente di sviluppo. È possibile spostarlo nella radice del progetto se si vuole archiviarlo 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 verrà visualizzata una finestra dell'applicazione.
Spostare il mouse nella finestra dell'applicazione e fare clic su un pulsante. Viene raggiunto il punto di interruzione. L'esecuzione del programma viene sospesa, Visual Studio torna in primo piano e viene visualizzato il punto di interruzione. Viene 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, gli oggetti, i thread, la memoria dell'applicazione e analizzare 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.
Nella finestra Stack di chiamate osservare le Chiamate a x11OpenGLWindow effettuate dal momento in cui Visual Studio ha avviato l'applicazione in Linux.

Lo stack di chiamate mostra il punto di interruzione in CommonRigidBodyBase::mouseMoveCallback e le chiamate che lo precedono, ad esempio OnMouseMove, X11OpenGLWindow::p umpMessage 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

Vcpkg di riferimento alla configurazione predefinita di CMake nei progetti CMake Installare e usare pacchetti con CMake in Visual Studio