Tutorial: Criar projetos multiplataforma do C++ no Visual Studio

Artigo
10/18/2023

Desenvolvimento do Visual Studio C e C++ não é mais apenas para Windows. Este tutorial mostra como usar o Visual Studio para desenvolvimento multiplataforma do C++ no Windows e no Linux. Ele é baseado no CMake, portanto, você não precisa criar nem gerar projetos do Visual Studio. Quando você abre uma pasta que contém um arquivo CMakeLists.txt, o Visual Studio define as configurações de IntelliSense e build automaticamente. Você pode começar rapidamente a editar, compilar e depurar seu código localmente no Windows. Então alterne a configuração para fazer o mesmo em Linux, tudo dentro do Visual Studio.

Neste tutorial, você aprenderá a:

clonar um projeto do CMake de software livre do GitHub
abra o projeto no Visual Studio
compilar e depurar um destino de executável no Windows
Adicionar uma conexão a um computador Linux
compilar e depurar o mesmo destino no Linux

Pré-requisitos

Configurar o Visual Studio para Desenvolvimento em C++ Multiplataforma
- Primeiro, instale o Visual Studio e escolha Desenvolvimento da área de trabalho com desenvolvimento em C++ e Linux com cargas de trabalho C++. Essa instalação mínima é de apenas 3 GB. Dependendo da sua velocidade de download, a instalação não deverá levar mais de 10 minutos.
Configurar um computador Linux para desenvolvimento em C++ multiplataforma
- O Visual Studio não exige nenhuma distribuição específica do Linux. O sistema operacional pode ser executado em um computador físico, em uma VM ou na nuvem. Você também pode usar o WSL (Subsistema do Windows para Linux). No entanto, para este tutorial, um ambiente gráfico é necessário. O WSL não é recomendado aqui, pois se destina principalmente a operações de linha de comando.
- O Visual Studio requer estas ferramentas na máquina Linux: compiladores C++, , , , gdbmakesshrsynce .zip Em sistemas baseados em Debian, você pode usar esse comando para instalar estas dependências:
```
sudo apt install -y openssh-server build-essential gdb rsync make zip
```
- O Visual Studio requer que uma versão recente do CMake no computador Linux com o modo de servidor habilitado (pelo menos 3.8). A Microsoft produz um build universal do CMake que você pode instalar em qualquer distribuição do Linux. É recomendável usar esse build para garantir que você tenha os recursos mais recentes. Você pode obter os binários do CMake da bifurcação da Microsoft do repositório CMake no GitHub. Vá para aquela página e baixe a versão que corresponde à arquitetura do seu sistema no computador Linux, em seguida, marque-o como um executável:
```
wget <path to binary>
chmod +x cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh
```
- Você pode ver as opções para executar o script com --help. É recomendável que você use a opção -prefix para especificar a instalação no caminho /usr porque /usr/bin é a localização padrão em que o Visual Studio procura CMake. O exemplo a seguir mostra o script do Linux-x86_64. Altere conforme necessário se você estiver usando uma plataforma de destino diferente.
```
sudo ./cmake-3.11.18033000-MSVC_2-Linux-x86_64.sh --skip-license --prefix=/usr
```
Git para Windows instalado em seu computador Windows.
Uma conta do GitHub.

Clonar um projeto do CMake de software livre do GitHub

Este tutorial usa o SDK do Bullet Physics no GitHub. Ele fornece simulações de detecção de colisão e física para muitos aplicativos. O SDK inclui programas executáveis de exemplo que compilam e executam sem ter que escrever outro código. Este tutorial não modifica nenhum código-fonte ou script de build. Para começar, clone o repositório bullet3 do GitHub no computador em que você tem o Visual Studio instalado.

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

No menu principal do Visual Studio, escolha Arquivo > Abrir > CMake. Navegue até o CMakeLists.txt arquivo na raiz do repositório bullet3 que você baixou.

Assim que você abre a pasta, a estrutura de pastas fica visível no Gerenciador de Soluções.

Essa exibição mostra exatamente o que está no disco, não uma exibição filtrada ou lógica. Por padrão, não mostra arquivos ocultos.
Escolha o botão Mostrar todos os arquivos para ver todos os arquivos na pasta.

Mude para a exibição de destinos

Quando você abre uma pasta que usa CMake, o Visual Studio gera automaticamente o cache de CMake. Essa operação pode levar alguns minutos, dependendo do tamanho do seu projeto.

Na Janela de Saída, selecione Mostrar saída de e, em seguida, escolha CMake para monitorar o status do processo de geração de cache. Quando a operação estiver concluída, ele diz "Extração de informações de destino concluída".

Após a conclusão dessa operação, o IntelliSense será configurado. Você pode compilar o projeto e depurar o aplicativo. O Visual Studio agora mostra uma exibição lógica da solução com base em um dos destinos especificados nos arquivos CMakeLists.
Use o botão Soluções e Pastas no Gerenciador de Soluções para alternar para exibição de destinos do 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.$

Veja como é essa exibição para o SDK do Bullet:

A exibição de destinos fornece uma exibição mais intuitiva do que essa base de código-fonte. Você pode ver que alguns destinos são bibliotecas e outros são executáveis.
Expanda um nó na exibição de destinos do CMake para ver seus arquivos de código-fonte, independentemente do local em que esses arquivos estejam no disco.

Adicionar uma configuração x64-Debug do Windows explícita

O Visual Studio cria uma configuração padrão de x64-Debug para Windows. As configurações são como o Visual Studio entende que destino de plataforma ele vai usar para o CMake. A configuração padrão não é representada no disco. Quando você adiciona explicitamente uma configuração, o Visual Studio cria um arquivo chamado CMakeSettings.json. Ele é preenchido com configurações para todas as configurações especificadas.

Adicionar uma configuração. Abra a lista suspensa Configuração na barra de ferramentas e selecione Gerenciar Configurações.

O Editor de Configurações do CMake é aberto. Selecione o sinal de adição verde no lado esquerdo do editor para adicionar uma configuração. A caixa de diálogo Adicionar configuração ao CMakeSettings é exibida:

Essa caixa de diálogo mostra todas as configurações incluídas com o Visual Studio, além de todas as configurações personalizadas que você criar. Se você quiser continuar a usar uma configuração x64-Debug que deve ser a primeira que você adicionar. Selecione x64-Debug e escolha o botão Selecionar. O Visual Studio cria o arquivo CMakeSettings.json com uma configuração para x64-Debug e o salva em disco. Você pode usar qualquer nome que desejar para suas configurações, alterando o parâmetro de nome diretamente no CMakeSettings.json.

Definir um ponto de interrupção, compilar e executar no Windows

Nesta etapa, depuramos um programa de exemplo que demonstra a biblioteca Bullet Physics.

Em Gerenciador de Soluções, selecione AppBasicExampleGui e expanda-o.
Abra o arquivo BasicExample.cpp.
Defina um ponto de interrupção que será atingido quando você clicar no aplicativo em execução. O evento de clique é tratado em um método dentro de uma classe auxiliar. Para rapidamente chegar lá:
1. Selecione a CommonRigidBodyBase da qual o struct BasicExample é derivado. É em torno da linha 30.
2. Clique com o botão direito do mouse e escolha Ir para Definição. Agora você está no cabeçalho CommonRigidBodyBase.h.
3. Na exibição do navegador acima, sua fonte, você deve ver que você está no CommonRigidBodyBase. À direita, você pode selecionar membros para examinar. Abra a lista suspensa e selecione mouseButtonCallback para ir para a definição dessa função no cabeçalho.
Coloque um ponto de interrupção na primeira linha nessa função. Isso será atingido quando você clica em um botão do mouse dentro da janela do aplicativo quando executado sob o depurador do Visual Studio.
Para inicializar o aplicativo, selecione o menu suspenso de inicialização na barra de ferramentas. É aquele com o ícone de reprodução verde que diz "Selecionar item de inicialização". Na lista suspensa, selecione AppBasicExampleGui.exe. O nome do executável agora é exibido no botão de inicialização:
Escolha o botão inicialização para compilar o aplicativo e as dependências necessárias e, em seguida, inicializá-lo com o depurador do Visual Studio anexado. Após alguns instantes, o aplicativo em execução é exibido:
Mova o mouse para a janela do aplicativo e, em seguida, clique em um botão para disparar o ponto de interrupção. Esse ponto de interrupção abre o Visual Studio novamente para o primeiro plano e o editor mostrando a linha em que a execução está em pausa. Você pode inspecionar variáveis de aplicativo, objetos, threads e memória ou percorrer seu código de modo interativo. Escolha Continuar para permitir que o aplicativo seja retomado, então saia dele normalmente. Outra opção é interromper a execução no Visual Studio usando o botão de parada.

Adicionar uma configuração do Linux e conectar-se ao computador remoto

Adicionar uma configuração do Linux. Clique com o botão direito do mouse no arquivo CMakeSettings.json na exibição Gerenciador de Soluções e selecione Adicionar Configuração. Você verá a mesma caixa de diálogo Adicionar Configuração a CMakeSettings de antes. Selecione Linux-Debug neste momento e salve o arquivo CMakeSettings.json (ctrl + s).
Visual Studio 2019 versão 16.6 ou posterior Role para baixo até a parte inferior do Editor de Configurações do CMake e selecione Mostrar configurações avançadas. Selecione Unix Makefiles como o gerador CMake e salve o arquivo CMakeSettings.json (ctrl + s).
Selecione Linux-Debug na configuração da lista suspensa.

Se esta for a primeira vez que você está se conectando a um sistema Linux, a caixa de diálogo Conectar-se ao Sistema Remoto será exibida.

A caixa de diálogo tem campos para o nome do host, porta, nome de usuário, tipo de autenticação e senha. Todos os campos estão em branco, exceto Porta está definida como 22 e Tipo de autenticação está definido como Senha.

Se você já tiver adicionado uma conexão remota, poderá abrir essa janela navegando até Ferramentas > Opções > Multiplataforma > Gerenciador de Conexões.
Forneça as informações de conexão em seu computador Linux e escolha Conectar. O Visual Studio adiciona esse computador como para CMakeSettings.json como sua conexão padrão para Linux-Debug. Também obterá os cabeçalhos do seu computador remoto de modo que você obtenha IntelliSense específica para a conexão remota. Em seguida, o Visual Studio envia seus arquivos para o computador remoto e gera o cache do CMake no sistema remoto. Essas etapas podem levar algum tempo, dependendo da velocidade da rede e da energia da máquina remota. Você sabe que ele está completo quando a mensagem "Extração de informações de destino concluída" aparece na janela de saída do CMake.

Definir um ponto de interrupção, compilar e executar no Linux

Como é um aplicativo de desktop, você precisa fornecer mais algumas informações de configuração para a configuração de depuração.

Na exibição de destinos do CMake, clique com o botão direito do mouse em AppBasicExampleGui e escolha Configurações de Depuração e de Inicialização para abrir o arquivo launch.vs.json que está na subpasta .vs oculta. Esse arquivo é local para seu ambiente de desenvolvimento. Você poderá movê-lo para a raiz do seu projeto se você quiser realizar o check-in e salvá-lo com sua equipe. Neste arquivo, foi adicionada uma configuração para AppBasicExampleGui. Essas configurações padrão funcionam na maioria dos casos, mas não aqui. Uma vez que esse é um aplicativo de desktop, que você precisará fornecer algumas informações adicionais para iniciar o programa para que possa vê-lo em nosso computador Linux.
Para descobrir o valor da variável de ambiente DISPLAY em seu computador Linux, execute este comando:
```
echo $DISPLAY
```
Na configuração de AppBasicExampleGui, há uma matriz de parâmetros, "pipeArgs". Ele contém uma linha: "${debuggerCommand}". É o comando que é iniciado gdb na máquina remota. O Visual Studio deve exportar a exibição para este contexto antes que o comando seja executado. Por exemplo, se o valor da sua exibição for :1, modifique essa linha da seguinte maneira:
```
"export DISPLAY=:1;${debuggerCommand}",
```
Inicie e depure seu aplicativo. Abra a lista suspensa Selecionar Item de Inicialização na barra de ferramentas e escolha AppBasicExampleGui. Em seguida, escolha o ícone de reprodução verde na barra de ferramentas ou pressione F5. O aplicativo e suas dependências são criados no computador Linux remoto e iniciados com o depurador do Visual Studio anexado. Em seu computador Linux remoto, você deverá ver uma janela do aplicativo.
Mova o mouse para a janela do aplicativo e clique em um botão. O ponto de interrupção é atingido. A execução do programa é pausada, o Visual Studio volta para o primeiro plano e você verá o ponto de interrupção. Você também deve ver uma Janela de Console do Linux ser exibida no Visual Studio. A janela fornece a saída do computador Linux remoto e também pode aceitar a entrada para stdin. Como qualquer janela do Visual Studio, você pode encaixá-la no local em que preferir vê-la. Sua posição é mantida em sessões futuras.

A saída na janela indica que as funções C11 carregadas dinamicamente usando dlopen/dlsym estão OK, um contexto GL 3.0 foi criado e o contexto de renderização Direct GLX obtido e tornado atual. A janela tem várias informações de versão para GL_VENDOR, GL_VERSION, GL_SHADING_LANGUAGE_VERSION e assim por diante.
Você pode inspecionar variáveis de aplicativo, objetos, threads e memória e percorrer seu código de forma interativa usando o Visual Studio. Porém, desta vez, você está fazendo tudo isso em um computador Linux remoto, em vez de em seu ambiente local do Windows. Você pode escolher Continuar para permitir que o aplicativo continue e saia normalmente, ou você pode escolher o botão parar, como na execução local.
Observe a janela Pilha de Chamadas e exiba as Chamadas para x11OpenGLWindow, já que o Visual Studio iniciou o aplicativo no Linux.

A pilha de chamadas mostra o ponto de interrupção em CommonRigidBodyBase::mouseMoveCallback e as chamadas que o precedem, como OnMouseMove, X11OpenGLWindow::p umpMessage e assim por diante.

O que você aprendeu

Neste tutorial, você clonou uma base de código diretamente do GitHub. Você o criou, executou e depurou no Windows sem modificações. Em seguida, você usou a mesma base de código, com pequenas alterações de configuração, para compilar, executar e depurar em um computador Linux remoto.

Próximas etapas

Saiba mais sobre como configurar e depurar projetos do CMake no Visual Studio:

Projetos do CMake no Visual Studio

Configurar um projeto do Linux CMake

Conectar-se ao computador Linux remoto

Personalizar as configurações de compilação do CMake

Configurar sessões de depuração do CMake

Implantar, executar e depurar o projeto do Linux

Referência de configuração predefinida do CMake vcpkg em projetos do CMake Instalar e usar pacotes com o CMake no Visual Studio