Tutorial: Depurar código C++ com o Visual Studio

Este artigo apresenta recursos do depurador do Visual Studio em uma explicação passo a passo. Quando se depura uma aplicação, geralmente executa-se a aplicação com o depurador associado. O depurador fornece muitas maneiras de examinar o que seu código está fazendo durante a execução do programa. Você pode percorrer seu código e examinar os valores armazenados em variáveis e definir inspeções em variáveis para ver quando os valores mudam. O depurador ajuda você a examinar o caminho de execução do seu código e confirmar que uma ramificação do código está em execução.

Neste tutorial, você:

• Inicie o depurador e pare nos pontos de interrupção
• Aprenda comandos para percorrer passo a passo pelo código no depurador
• Inspecionar variáveis em dicas de dados e janelas do depurador
• Examine a pilha de chamadas

Se és novo na depuração, poderás querer ler Depuração para iniciantes absolutos antes de iniciares este tutorial. Se você quiser uma visão de nível mais alto dos recursos do depurador, consulte Primeira olhada no depurador.

Pré-requisitos

• O Visual Studio 2022 versão 17.12 ou posterior com o desenvolvimento do Desktop com C++ carga de trabalho instalada.

  • Para instalar o Visual Studio 2022 gratuitamente, vá para a página de downloads do Visual Studio.

  • Se você já tiver o Visual Studio, poderá instalar a carga de trabalho de dentro do IDE (Ambiente de Desenvolvimento Interativo):

    1. Selecione Ferramentas>Obter Ferramentas e Recursos.

    2. No instalador do Visual Studio, selecione o separador Cargas de Trabalho.

    3. Selecione a carga de trabalho desenvolvimento de Desktop com C++ e, em seguida, selecione Modificar.

    4. Siga as instruções e conclua a instalação.

• Este tutorial usa um aplicativo de demonstração C++ e as capturas de tela apresentam sintaxe C++. A maioria dos recursos demonstrados também são aplicáveis a C#, Visual Basic, F#, Python, JavaScript e outras linguagens suportadas pelo Visual Studio. Existem algumas limitações a ter em mente:

  • F#: O recurso Editar e continuar não é suportado.

  • F# e JavaScript: A janela Autos não é suportada.

Criar um projeto

Siga estas etapas para criar um projeto de aplicativo de console C++ no Visual Studio. O tipo de projeto fornece todos os arquivos de modelo que você precisa para começar rapidamente:

1. Na janela Iniciar do Visual Studio (Janela ArquivoIniciar), selecione Criar um novo projeto:

   

2. Defina o filtro Language como C++ e defina o filtro Platform como Windows.

3. Na caixa de Pesquisa , digite console, e selecione o modelo de Aplicativo de Console na lista de resultados:

   

   Observação

   Se não vir o modelo de Aplicação de Consola , pode instalá-lo na janela Criar um novo projeto . Localize o Não encontrou o que procura? seção que segue os resultados da pesquisa e selecione Instalar mais ferramentas e recursos. No instalador do Visual Studio, selecione a carga de trabalho Desenvolvimento de ambiente de trabalho com C++ e atualize a sua instalação. Para obter mais informações, consulte a seção Pré-requisitos.

4. Selecione Avançar para continuar na página de configuração.

5. Insira get-started-debugging como o nome do Projeto e o nome da Solução para a sua nova aplicação. Escolha o de localização de padrão ou navegue até um caminho diferente em seu ambiente.

6. Selecione Criar para criar o novo projeto Node.js.

O Visual Studio cria seu novo projeto e abre sua hierarquia de projeto em Gerenciador de Soluções. O arquivo get-started-debugging.cpp é aberto no editor de códigos.

Criar o aplicativo

Crie um novo aplicativo para seu projeto editando o arquivo get-started-debugging.cpp no editor de códigos.

Substitua o conteúdo padrão fornecido pelo modelo pelo seguinte código:

#include <string>
#include <vector>
#include <iostream>

void SendMessage(const std::wstring& name, int msg)
{
   std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main()
{
   std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
   std::wstring name = L"";
   std::vector<int> a(10);
   std::wstring key = L"";

   for (int i = 0; i < letters.size(); i++)
   {
      name += letters[i];
      a[i] = i + 1;
      SendMessage(name, a[i]);
   }
   std::wcin >> key;
   return 0;
}

Inicie o depurador

Agora estás pronto para começar a depurar o teu código atualizado:

1. Inicie a sessão de depuração selecionando F5 ou Depurar > Iniciar Depuração. Você também pode selecionar Iniciar Depuração (ícone de seta verde sólida) na barra de ferramentas Depurar.

   O atalho de teclado F5 inicia a aplicação com o depurador ligado ao processo da aplicação, mas ainda não tem nada de especial para examinar no código. O aplicativo simplesmente carrega e você vê a saída do console:

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

   Mais adiante no tutorial, você examina mais de perto este aplicativo no depurador e explora outros recursos de depuração.

2. Pare o depurador selecionando Parar (ícone quadrado vermelho) na barra de ferramentas de Depuração. Você também pode usar o Shift + F5 atalho de teclado.

3. Na janela do console do aplicativo em execução, selecione qualquer tecla e, em seguida, selecione Enter para fechar a janela.

Definir um ponto de interrupção e iniciar o depurador

Tente definir um ponto de interrupção e pausar no ponto selecionado no depurador:

1. Retorne ao arquivo get-started-debugging.cpp no editor de códigos e localize o loop de for da função main:

      for (int i = 0; i < letters.size(); i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
   

2. Defina um ponto de interrupção na linha que contém a instrução de código name += letters[i]; clicando na margem esquerda da linha da instrução. O Visual Studio adiciona um círculo vermelho na calha para indicar o ponto de interrupção definido.

   Dica

   Você também pode colocar o cursor em uma linha de código e selecionar F9 para alternar o ponto de interrupção dessa linha.

   Os pontos de interrupção são uma das funcionalidades mais básicas e essenciais da depuração confiável. Um ponto de interrupção indica onde você deseja que o Visual Studio suspenda seu código em execução. Quando a execução é pausada, você pode examinar os valores das variáveis, examinar o comportamento da memória ou verificar se uma ramificação do código está sendo executada.

3. Inicie seu aplicativo no depurador selecionando F5 ou Iniciar Depuração.

   O Visual Studio inicia a execução do seu aplicativo. Quando o depurador atinge o ponto de interrupção definido, o processo de depuração é pausado.

   O Visual Studio adiciona uma seta amarela ao círculo vermelho do ponto de interrupção na margem para representar a linha de código onde o depurador está pausado. A execução do programa é pausada e a instrução indicada está aguardando para ser processada.

   

   Observação

   A ação F5 é relativa ao estado de execução atual do seu aplicativo. Se o aplicativo não estiver em execução e você selecionar F5 , o depurador iniciará o aplicativo e continuará a execução até atingir o primeiro ponto de interrupção definido. Este comportamento corresponde ao comando Debug>Start Debugging. Se o seu aplicativo já estiver em execução e você selecionar F5, a execução do aplicativo continuará até que o depurador atinja o próximo ponto de interrupção ou fim do programa. Esse comportamento corresponde ao comando Debug>Continue.

Os pontos de interrupção são um recurso útil quando você conhece a linha de código ou a seção de código que deseja examinar em detalhes. Para obter informações sobre os diferentes tipos de pontos de interrupção que pode definir, como pontos de interrupção condicionais, consulte Use o tipo certo de ponto de interrupção.

Percorra passo a passo o código no depurador

Uma maneira conveniente de procurar seu código no depurador é usar comandos de etapa. Esses comandos permitem que você Step Into, Step Overe Step out de uma seção de código e também Step Backward na execução do aplicativo.

O procedimento a seguir destaca como usar atalhos de teclado com comandos passo a passo para trabalhar rapidamente no seu código. (As ações de menu equivalentes são mostradas entre parênteses.)

1. Inicie seu aplicativo no depurador selecionando F5 ou Iniciar Depuração.

2. Enquanto o depurador está pausado no loop de for na função main, selecione F11 (Debug > Step Into) duas vezes para avançar até à chamada do método SendMessage.

   Depois de selecionar F11 duas vezes, a execução continua para a instrução de código SendMessage(name, a[i]);.

3. Selecione F11 novamente para entrar no método SendMessage.

   Observe que o ponteiro amarelo avança para o método SendMessage:

   

   O atalho de teclado F11 inicia o comando Step Into, que avança a execução do aplicativo uma instrução de cada vez. É uma boa maneira de examinar o fluxo de execução com mais detalhes. Por padrão, o depurador ignora o código que não é do usuário. Para obter mais informações, consulte Just My Code. Mais adiante no tutorial, você aprenderá maneiras de se mover mais rapidamente pelo seu código.

4. Depois de examinar o método SendMessage, você pode continuar a depuração com o comando Step out. Selecione Shift + F11 (Debug > Step out).

   Este comando retoma a execução do aplicativo (e avança o depurador) até que o método ou função atual retorne.

   Quando o comando é concluído, o depurador pausa no loop de for do método main na chamada do método SendMessage.

5. Selecione F11 várias vezes até retornar novamente à chamada de método SendMessage.

6. Enquanto o depurador é pausado na chamada do método, selecione F10 (Debug > Step Over).

   

   Observe que desta vez o depurador não entra no método SendMessage. O atalho F10 avança o depurador sem entrar em funções ou métodos no código da aplicação, embora o código ainda seja executado. Quando você seleciona F10 na chamada de método SendMessage (em vez de F11), você Step Over o código de implementação para SendMessage. Essa abordagem é útil para ignorar código que não precisa inspecionar atualmente. Para obter mais informações sobre diferentes maneiras de navegar pelo seu código, consulte Navegar no código no depurador.

Navegue pelo seu código com o Run to Click

Outra maneira de trabalhar com o código no depurador é com o recurso Executar e Clicar. Esta ação é semelhante à definição de um ponto de interrupção temporário.

Continue com sua sessão de depuração:

1. Selecione F5 para avançar para o ponto de interrupção no seu código.

2. No editor de códigos, role até a definição do método SendMessage e passe o mouse sobre a função std::wcout.

   Passe o cursor até que a Run to Click (ícone de seta verde) apareça à esquerda da instrução de código. Se passares com o rato sobre o ícone, verás a dica de ferramenta "Executar até aqui".

   

3. Selecione Executar para Clicar.

   O depurador avança a execução para a posição indicada. Neste exemplo, o debugger alcança a chamada para a função std::wcout.

A ação executar para clicar é útil para se locomover rapidamente em uma região visível do código do aplicativo. Você pode usar o recurso em qualquer arquivo aberto no editor de códigos.

Reinicie seu aplicativo rapidamente

Reinicie rapidamente a sua aplicação selecionando Reiniciar (ícone de seta circular) na Barra de Ferramentas de Depuração. Você também pode selecionar Depurar > Reiniciar ou usar o Ctrl + Shift + F5 atalho de teclado.

O recurso Reiniciar é mais eficiente do que parar o aplicativo e iniciar o depurador novamente.

Quando você seleciona Reiniciar, o depurador pausa no primeiro ponto de interrupção que encontra durante a execução. Neste exemplo, o depurador para novamente no ponto de interrupção definido dentro do loop for.

Inspecione variáveis com dicas de dados

Recursos que ajudam a inspecionar variáveis são um dos benefícios mais úteis de trabalhar com o depurador. Muitas vezes, quando você está depurando um problema, está tentando descobrir se as variáveis estão armazenando valores esperados em momentos específicos. O Visual Studio fornece várias maneiras de ajudá-lo a concluir essa tarefa.

Continue com sua sessão de depuração:

1. Enquanto o depurador é pausado na instrução name += letters[i], passe o mouse sobre a variável letters. Selecione a seta de expandir/recolher à esquerda do nome da variável e visualize as suas propriedades no menu flutuante.

   O recurso dicas de dados mostra todos os elementos que a variável contém. Observe o valor padrão, size={10}:

   

2. Em seguida, passe o mouse sobre a variável name e observe seu valor atual, uma cadeia de caracteres vazia ("").

3. Selecione F5 (Debug>Continue) repetidamente para iterar várias vezes no loop for. Sempre que o depurador fizer uma pausa no ponto de interrupção, passe o mouse sobre a variável name e verifique o valor atual:

   

   O valor da variável muda a cada iteração do loop de for, mostrando valores de f, depois fr, depois free assim por diante.

Inspecione variáveis com as janelas Autos e Locais

Outra abordagem para inspecionar variáveis e valores é usando as janelas Autos e Locals. Por padrão, essas janelas aparecem abaixo do editor de código no IDE do Visual Studio enquanto você está depurando seu aplicativo:

1. Observe a janela Autos abaixo do editor de código.

   Se você não vir a janela durante a sessão de depuração, selecione Depurar>Windows>Autos para abrir a janela.

   A janela Autos mostra todas as variáveis usadas na linha atual ou na linha anterior, juntamente com seu valor atual. Tenha em mente que linguagens de programação específicas podem demonstrar um comportamento exclusivo para variáveis e propriedades. Para obter mais informações, consulte o Visual Studio Language Guidance.

2. Em seguida, dê uma olhada na janela Locals. Por padrão, esta janela é alinhada ao lado da janela Autos.

   Se não vir a janela durante a sessão de depuração, selecione Depurar WindowsLocais para abrir a janela

3. Na janela Locals , expanda a variável letters para mostrar os elementos que ela contém.

   

   A janela Locals mostra as variáveis que estão no escopo atual, ou seja, o contexto de execução atual.

Monitorizar uma variável

Se você estiver interessado em observar o comportamento de uma variável específica, você pode definir um observação:

No editor de códigos, clique com o botão direito do mouse na variável name e selecione Adicionar Observação. A janela Watch abre-se abaixo do editor de código. Você pode usar uma janela Watch para especificar uma variável (ou uma expressão) que deseja acompanhar.

Ao observar a variável name durante a execução do aplicativo no depurador, você pode ver sua alteração de valor. Ao contrário das outras janelas de variáveis, a janela Watch mostra sempre as variáveis que se estão a monitorizar. Quando uma variável monitorizada não está no escopo, o nome da variável fica atenuado.

Examine a pilha de chamadas

A janela Call Stack no Visual Studio mostra a ordem em que os métodos e funções são chamados. Esta janela é semelhante à perspetiva Debug em alguns IDEs como o Eclipse. Por padrão, a pilha de chamadas é visível no canto inferior direito do painel durante a sessão de depuração, abaixo do editor de código.

1. Enquanto o depurador está pausado no loop de for, selecione a janela da pilha de chamadas para ver a estrutura de chamada atual.

   Se você não vir a janela durante a sessão de depuração, selecione Depurar de Pilha de Chamadas do Windowspara abrir a janela.

2. Selecione F11 (Debug>Step Into) algumas vezes até ver a pausa do depurador no método SendMessage.

3. Observe novamente a janela do Call Stack:

   

   Na janela Call Stack, a linha superior mostra a função atual (o método SendMessage neste aplicativo). A segunda linha mostra que o método SendMessage foi chamado a partir do método main, e assim por diante.

A pilha de chamadas é uma boa maneira de examinar e entender o fluxo de execução de um aplicativo:

• Clique duas vezes em uma linha de código para navegar até o código-fonte. Essa ação também altera o escopo atual sob inspeção pelo depurador, mas não avança o depurador.

• Aceda aos menus de clique com o botão direito para elementos de programação na janela Pilha de chamadas. Por exemplo, você pode inserir pontos de interrupção em funções especificadas, avançar o depurador usando Executar para Cursore navegar até o código-fonte. Para obter mais informações, consulte Exibir a pilha de chamadas e usar a janela Pilha de chamadas no depurador.

Alterar o fluxo de execução

Outro recurso do depurador no Visual Studio é a capacidade de alterar o fluxo de execução do seu aplicativo:

1. Selecione F11 (Debug>Step Into) duas vezes para executar a função std::wcout.

2. Enquanto o depurador está pausado na chamada do método SendMessage, selecione e arraste a seta amarela (o ponteiro de execução) para a esquerda da variável e mova a seta para a instrução de código anterior, std::wcout.

3. Selecione F11 novamente.

   O debugger executa a função std::wcout novamente. Você pode acompanhar o processo na saída do terminal.

   Ao alterar o fluxo de execução, você pode fazer coisas como testar diferentes caminhos de execução de código ou executar novamente o código sem reiniciar o depurador.

   Atenção

   Preste muita atenção ao trabalhar com esse recurso. Quando se seleciona a seta amarela, o Visual Studio exibe um aviso no tooltip indicando que a alteração da execução pode ter consequências indesejadas. Você também pode ver outros avisos, dependendo do seu cenário. Lembre-se de que mover o ponteiro não pode reverter seu aplicativo para um estado anterior do aplicativo.

4. Selecione F5 para concluir a execução do aplicativo.

Conteúdo relacionado

• Primeira olhada no depurador do Visual Studio
• Navegue pelo código usando o depurador do Visual Studio
• Use o tipo certo de ponto de interrupção (.NET, .NET Framework, C++, Todos os idiomas)