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

Este artigo apresenta os recursos do depurador do Visual Studio em um passo a passo. Ao depurar um aplicativo, você geralmente executa o aplicativo com o depurador anexado. O depurador fornece várias 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 relógios em variáveis para ver quando os valores são alterados. O depurador ajuda você a examinar o caminho de execução do código e confirmar se uma ramificação (ou branch) de código está rodando.

Neste tutorial, você:

• Iniciar o depurador e pausar em pontos de interrupção
• Aprender os comandos para percorrer o código no depurador
• Inspecionar variáveis em dicas de dados e janelas do depurador
• Examinar a pilha de chamadas

Se você não estiver familiarizado com a depuração, talvez queira ler Depuração para iniciantes absolutos antes de iniciar este tutorial. Caso deseje obter uma exibição de nível superior das funcionalidades do depurador, confira Introdução ao depurador.

Pré-requisitos

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

  • Para instalar o Visual Studio 2022 gratuitamente, acesse a página 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 a guia Cargas de Trabalho.

    3. Selecione a carga de trabalho Desenvolvimento para Desktop com C++ e selecione Modificar.

    4. Siga os prompts e conclua a instalação.

• Este tutorial usa um aplicativo de demonstração C++ e as capturas de tela apresentam a sintaxe C++. A maioria dos recursos demonstrados também é aplicável a C#, Visual Basic, F#, Python, JavaScript e outros idiomas compatíveis com o Visual Studio. Há algumas limitações para ter em mente:

  • F#: o recurso de edição e continuação não é suportado.

  • F# e JavaScript: A janela de 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 necessários para começar rapidamente:

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

   

2. Defina o filtro de Linguagem para C++ e defina o filtro de Plataforma para Windows.

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

   

   Nota

   Se você não vir o modelo de Aplicativo de Console, poderá instalá-lo na janela Criar um projeto. Localize a seção Não está encontrando o que está procurando? que está após os resultados da pesquisa e selecione Instalar mais ferramentas e recursos. No Visual Studio Installer, selecione a carga de trabalho Desenvolvimento para Desktop com C++ e atualize sua instalação. Para obter mais informações, consulte a seção Pré-requisitos.

4. Selecione Próximo para continuar na página de configuração.

5. Insira introducao-a-depuracao como o Nome do projeto e o Nome da solução para seu novo aplicativo. Escolha o Local padrão ou navegue até um caminho diferente em seu ambiente.

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

O Visual Studio cria seu novo projeto e abre sua hierarquia de projetos no do Gerenciador de Soluções. O arquivo get-started-debugging.cpp está aberto no editor de código.

Criar o aplicativo

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

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;
}

Iniciar o depurador

Agora você está pronto para iniciar o debugging do 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 de depuração.

   O atalho de teclado F5 inicia o aplicativo com o depurador anexado ao processo do aplicativo, mas você ainda não tem nada 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
   

   Posteriormente, no tutorial, você examinará mais de perto esse aplicativo no depurador e explorará outros recursos de depuração.

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

3. Na janela do console do aplicativo em execução, selecione qualquer chave e 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ódigo e localize o loop 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]; selecionando a margem esquerda na linha da instrução. O Visual Studio adiciona um círculo vermelho na margem 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.

   Pontos de interrupção são um dos recursos mais básicos e essenciais de uma depuração confiável. Um ponto de interrupção indica onde você deseja que o Visual Studio suspenda o código em execução. Quando a execução é pausada, você pode dar uma olhada nos valores das variáveis, examinar o comportamento da memória ou verificar se um branch de código está sendo executado.

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

   O Visual Studio inicia a execução do 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 instrução de código em que o depurador está pausado. A execução do programa está pausada e a instrução indicada está aguardando para ser processada.

   

   Nota

   A ação F5 é relativa ao estado de execução atual do aplicativo. Se o aplicativo não estiver em execução e você selecionar F5, o depurador iniciará seu aplicativo e continuará a execução até atingir o primeiro ponto de interrupção definido. Esse comportamento mapeia para o comando Depurar>Iniciar a Depuração. Se o 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 Depurar>Continuar.

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 podem ser definidos, como pontos de interrupção condicionais, consulte Usar o tipo certo de ponto de interrupção.

Execute seu código passo a passo no depurador

Uma maneira conveniente de navegar pelo seu código no depurador é usar os comandos de etapa. Esses comandos permitem que você use as opções Intervir, Pular método e Sair do método de uma seção de código e também Retroceda na execução do aplicativo.

O procedimento a seguir destaca como usar atalhos de teclado com comandos de etapa para trabalhar rapidamente em 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 (Depurar > Intervir) duas vezes para avançar para a chamada do método SendMessage.

   Depois de selecionar F11 duas vezes, a execução continuará na 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 por vez. É uma boa maneira de examinar o fluxo de execução com mais detalhes. Por padrão, o depurador ignora o código nonuser. Para obter mais informações, consulte Just My Code. Posteriormente, no tutorial, você aprenderá maneiras de se mover mais rapidamente pelo código.

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

   Esse 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 for do método main na chamada do método SendMessage.

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

6. Enquanto o depurador estiver pausado na chamada do método, selecione F10 (Depurar > Pular Método).

   

   Observe neste momento que o depurador não intervém no método SendMessage. O atalho F10 faz o depurador avançar sem acessar funções ou métodos no código da aplicação (o código continua a ser executado). Ao selecionar F10 na chamada do método SendMessage (em vez de F11), você escolhe Pular Método no código de implementação para SendMessage. Essa abordagem é útil para passar pelo código que você não precisa inspecionar no momento. Para obter mais informações sobre diferentes maneiras de percorrer seu código, confira Navegar pelo código no depurador.

Navegar no seu código com Executar até o Clique

Outra maneira de trabalhar com seu código no depurador é com o recurso Executar até o Clique. Essa ação é semelhante à configuração de um ponto de interrupção temporário.

Continue com a sessão de debug.

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

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

   Passe o mouse até que Executar até o Clique (ícone de seta verde) apareça à esquerda da instrução de código. Se você passar o mouse sobre o ícone, verá a dica de ferramenta "Executar até aqui":

   

3. Selecione Executar até o Clique.

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

A ação Executar até o Clique é útil para navegar 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ódigo.

Reinicie seu aplicativo rapidamente

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

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 encontrado durante a execução. Neste exemplo, o depurador para novamente no ponto de interrupção definido dentro do loop for.

Inspecionar variáveis com dicas de dados

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

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

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

   O recurso de 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 (Depurar>Continuar) algumas vezes para iterar várias vezes pelo loop de for. Sempre que o depurador pausar no ponto de interrupção, passe o mouse sobre a variável name e verifique o valor atual:

   

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

Inspecionar variáveis com as janelas Autos e Locais

Outra abordagem para inspecionar variáveis e valores é usar as janelas Autos e Locais. 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>Janelas>Automáticos para abrir a janela.

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

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

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

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

   

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

Monitore uma variável

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

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

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 Monitoramento sempre mostra as variáveis que você está monitorando. Quando uma variável observada não está no escopo, o nome da variável fica esmaecido.

Examinar a pilha de chamadas

A janela Pilha de Chamadas no Visual Studio mostra a ordem na qual métodos e funções são chamados. Essa janela é semelhante à perspectiva de depuração em alguns IDEs, como o Eclipse. Por padrão, a pilha de chamadas fica visível no painel inferior direito abaixo do editor de código durante a sessão de depuração.

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

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

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

3. Examine a janela Pilha de Chamadas novamente:

   

   Na janela Pilha de Chamadas, 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 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 que está sendo inspecionado pelo depurador, mas não faz com que o depurador avance.

• Acesse os menus de clique com o botão direito do mouse 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 até o Cursor e navegar pelo 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 (Depurar>Passo para) 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 depurador executa novamente a função std::wcout. Você pode acompanhar o processo na saída do terminal.

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

   Cuidado

   Preste atenção ao trabalhar com esse recurso. Quando você seleciona a seta amarela, o Visual Studio exibe um aviso na dica de ferramenta indicando que a alteração de execução pode ter consequências não intencionais. Você também pode ver outros avisos, dependendo do seu cenário. Tenha em mente que mover o ponteiro não pode reverter seu aplicativo para um estado de aplicativo anterior.

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

Conteúdo relacionado

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