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

O desenvolvimento de C e C++ do Visual Studio não é mais apenas para o 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 ou gerar projetos do Visual Studio. Quando você abre uma pasta que contém um arquivo CMakeLists.txt, o Visual Studio define automaticamente as configurações do IntelliSense e do build. Você pode iniciar rapidamente a edição, a criação e a depuração do código localmente no Windows. Em seguida, alterne sua configuração para fazer o mesmo no Linux, tudo de dentro do Visual Studio.

Neste tutorial, você aprenderá como:

Pré-requisitos

• Configurar o Visual Studio para desenvolvimento em C++ multiplataforma

  • Primeiro, instale o Visual Studio e escolha o desenvolvimento de área de trabalho com C++ e desenvolvimento Linux com C++. Essa instalação mínima é de apenas 3 GB. Dependendo da velocidade de download, a instalação não deve levar mais de 10 minutos.

• Configurar um computador Linux para desenvolvimento em C++ multiplataforma

  • O Visual Studio não requer nenhuma distribuição específica do Linux. O sistema operacional pode estar em execução em um computador físico, em uma VM ou na nuvem. Você também pode usar o Subsistema do Windows para Linux (WSL). No entanto, para este tutorial, é necessário um ambiente gráfico. O WSL não é recomendado aqui, pois destina-se principalmente a operações de linha de comando.

  • O Visual Studio requer essas ferramentas no computador Linux: compiladores C++, gdb, ssh, rsynce makezip. Em sistemas baseados em Debian, você pode usar este comando para instalar essas dependências:

    sudo apt install -y openssh-server build-essential gdb rsync make zip
    

  • O Visual Studio requer uma versão recente do CMake no computador Linux que tenha 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. Recomendamos que você use 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 essa página e baixe a versão que corresponde à arquitetura do sistema em seu computador Linux e, em seguida, marque-a 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. Recomendamos que você use a opção -prefix para especificar a instalação no caminho /usr , pois /usr/bin é o local padrão em que o Visual Studio procura o CMake. O exemplo a seguir mostra o script x86_64 Linux. Altere-o 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 sistema Windows.

• Uma conta do GitHub.

Clonar um projeto do CMake de software livre do GitHub

O SDK de Física do Bullet no GitHub é utilizado neste tutorial. 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 precisar escrever outro código. Este tutorial não modifica nenhum dos scripts de build ou código-fonte. Para iniciar, 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

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

   

   Assim que você abrir a pasta, sua estrutura de pastas ficará visível no Gerenciador de Soluções.

   

   Essa exibição mostra exatamente o que está em disco, não uma exibição lógica ou filtrada. Por padrão, ele não mostra arquivos ocultos.

2. Escolha o botão Mostrar todos os arquivos para ver todos os arquivos na pasta.

   

Alternar para a exibição de alvos

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

1. Na Janela de Saída, selecione Mostrar saída e escolha CMake para monitorar o status do processo de geração de cache. Quando a operação for concluída, ela 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 nos destinos especificados nos arquivos CMakeLists.

2. Use o botão Soluções e Pastas no Gerenciador de Soluções para alternar para a Exibição de Destinos do CMake.

   

   Veja como é essa visualização no Bullet SDK:

   

   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.

3. 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 explícita do Windows x64-Debug

O Visual Studio cria uma configuração padrão x64-Debug para Windows. As configurações são como o Visual Studio entende qual destino de plataforma ele 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.

1. Adicione uma nova 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 nova 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 no Visual Studio, além de todas as configurações personalizadas que você criar. Se você quiser continuar a usar uma configuração x64-Debug, essa deve ser a primeira que você adiciona. Selecione x64-Depurar 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 os nomes que quiser 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.

1. No Gerenciador de Soluções, selecione AppBasicExampleGui e expanda-o.

2. Abra o arquivo BasicExample.cpp.

3. Defina um ponto de interrupção que é atingido quando você clica no aplicativo em execução. O evento de clique é tratado em um método dentro de uma classe auxiliar. Para chegar lá rapidamente:

   1. Selecione CommonRigidBodyBase do 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 a serem examinados. Abra a lista suspensa e selecione mouseButtonCallback para ir para a definição dessa função no cabeçalho.

      

4. Coloque um ponto de interrupção na primeira linha dentro dessa 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.

5. 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". No menu suspenso, selecione AppBasicExampleGui.exe. O nome executável agora é exibido no botão inicializar:

   

6. 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 será exibido:

   

7. Mova o mouse para a janela do aplicativo e clique em um botão para ativar o ponto de interrupção. O ponto de interrupção traz o Visual Studio de volta ao primeiro plano e o editor mostra a linha em que a execução é pausada. Você pode inspecionar as variáveis de aplicativo, objetos, threads e memória ou percorrer seu código interativamente. Escolha Continuar para deixar o aplicativo retomar e, em seguida, sair dele normalmente. Ou interrompa a execução no Visual Studio usando o botão parar.

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

1. Adicionar uma configuração do Linux. Clique com o botão direito do mouse no arquivo CMakeSettings.json no modo de exibição Gerenciador de Soluções e selecione Adicionar Configuração. Você verá a mesma caixa de diálogo Adicionar Configuração ao CMakeSettings como antes. Selecione Linux-Debug desta vez e salve o arquivo CMakeSettings.json (ctrl + s).

2. 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).

3. Selecione Linux-Debug na configuração da lista suspensa.

   

   Se for a primeira vez que você estiver se conectando a um sistema Linux, a caixa de diálogo Conectar 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 que a porta está definida como 22 e o tipo de autenticação é 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.

4. Forneça as informações de conexão para 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 potência do computador remoto. Você sabe que ela é concluída 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 esse é um aplicativo de área de trabalho, você precisará fornecer mais algumas informações de configuração para a configuração da depuração.

1. 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, uma configuração foi adicionada para AppBasicExampleGui. Essas configurações padrão funcionam na maioria dos casos, mas não aqui. Como é um aplicativo da área de trabalho, você precisa fornecer algumas informações adicionais para iniciar o programa para poder vê-lo em seu computador Linux.

2. Para localizar o valor da variável DISPLAY de ambiente 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 lança gdb no computador remoto. O Visual Studio deve exportar a exibição para esse contexto antes que esse comando seja executado. Por exemplo, se o valor da exibição for :1, modifique essa linha da seguinte maneira:

   "export DISPLAY=:1;${debuggerCommand}",
   

3. 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, em seguida, são iniciados com o depurador do Visual Studio anexado. Em seu computador Linux remoto, você deverá ver uma janela do aplicativo aparecer.

4. 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 do console do Linux aparecer no Visual Studio. A janela fornece saída do computador Linux remoto e também pode aceitar entrada para stdin. Como qualquer janela do Visual Studio, você pode acoplá-la onde 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 são OK, um contexto GL 3.0 foi criado e o contexto de renderização do DIRECT GLX obtido e atualizado. A janela tem várias informações de versão para GL_VENDOR, GL_VERSION, GL_SHADING_LANGUAGE_VERSION e assim por diante.

5. Você pode inspecionar as variáveis de aplicativo, objetos, threads, memória e percorrer seu código interativamente usando o Visual Studio. Mas, desta vez, você está fazendo tudo isso em um computador Linux remoto em vez do seu ambiente local do Windows. Você pode escolher Continuar para permitir que o aplicativo retome e saia normalmente ou pode escolher o botão parar, como acontece com a execução local.

6. 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, etc.

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 criar, executar e depurar em um computador Linux remoto.

Próximas etapas

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