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

Neste tutorial, você depura um aplicativo C++ usando o depurador do Visual Studio. Ao depurar uma aplicação, você geralmente executa a sua aplicação com o depurador conectado. 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 seu código e confirmar que um ramo de código está em execução.

Neste tutorial, você:

• Iniciar o depurador e pausar nos 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
• Definir argumentos de linha de comando para seu aplicativo

Se você não estiver familiarizado com a depuração, talvez queira ler a Depuração para iniciantes absolutos antes de iniciar este tutorial. Se você quiser uma exibição de nível superior dos recursos do depurador, consulte Primeiro examinar o depurador.

Pré-requisitos

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

  • Para instalar o Visual Studio 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, em seguida, 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#: não há suporte para o recurso editar e continuar .
  • F# e JavaScript: não há suporte para a janela Autos .

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 de Início do Visual Studio (Arquivo>Janela de Início), selecione Criar um novo projeto:

   

2. Defina o filtro de linguagem como C++ e defina o filtro de plataforma como Windows.

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

   

   Observação

   Se você não vir o modelo de Aplicativo de Console , poderá instalá-lo na janela Criar um novo projeto . Localize a seção Não encontrar o que você está procurando? Que segue os resultados da pesquisa e selecione Instalar mais ferramentas e recursos. No Instalador do Visual Studio, selecione o trabalho de desenvolvimento de desktop com C++ e atualize sua instalação. Para saber mais, confira a seção Pré-requisitos.

4. Selecione Próximo 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 seu novo aplicativo. Escolha o Local padrão ou navegue para um caminho diferente no 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 get-started-debugging.cpp arquivo está aberto no editor de código.

Criar o aplicativo

Crie um novo aplicativo para seu projeto editando o get-started-debugging.cpp arquivo 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 começar a depurar o 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 ainda não há 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 de depuração. Você também pode usar o atalho de teclado Shift + F5 .

3. Na janela do console do aplicativo em execução, selecione qualquer chave 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 get-started-debugging.cpp arquivo no editor de código e localize o for loop da main função:

      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 medianiz 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 medianiz para indicar a instrução de código em que o depurador será pausado. A execução do programa está 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 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é chegar ao primeiro ponto de interrupção definido. Esse comportamento é mapeado para o comando Depurar>Iniciar 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. Este 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 você pode definir, como pontos de interrupção condicionais, consulte Usar o tipo certo de ponto de interrupção.

Passe passo a passo pelo seu código no depurador

Uma maneira conveniente de navegar pelo código no depurador é usando comandos de etapa. Esses comandos permitem que você entre, avançar sobre, e saia 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 estiver em pausa no loop for da função main, pressione F11 (Depurar > Intervir) duas vezes para avançar até a chamada de método SendMessage.

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

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

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

   

   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 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 SendMessage método, você pode continuar a depuração com o comando Step Out . Pressione Shift + F11 (Depurar > Sair).

   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 faz uma pausa no loop for do método main na chamada do método SendMessage.

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

6. Enquanto o depurador estiver em pausa na chamada de método, pressione F10 (Depurar > Intervir).

   

   Observe neste momento que o depurador não intervém no método SendMessage. O atalho de teclado F10 avança o depurador sem intervir em funções ou métodos no código do aplicativo (o código ainda é executado). Ao pressionar F10 na chamada de método SendMessage (em vez de F11), você vai Intervir no código de implementação de 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, consulte Navegar código no depurador.

Navegar pelo código com Executar até o Clique

Outra maneira de navegar pelo 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 a sessão de depuração:

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 SendMessage método e passe o mouse sobre a std::wcout função.

   Passe o mouse até que a opção Executar até o Clique (ícone de seta verde) apareça à esquerda da instrução de código. Ao passar o mouse sobre o ícone, ele exibe a dica de ferramenta "Realizar a execução até aqui":

   

3. Selecione Executar até o Clique .

   O depurador avança a execução até a posição indicada. Neste exemplo, o depurador vai até a chamada da função std::wcout.

A ação Run to Click é ú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. Também é possível 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 for loop.

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 a sessão de depuração:

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

   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 name variável e observe seu valor atual, uma cadeia de caracteres vazia ("").

3. Selecione F5 (Depurar>Continuar) algumas vezes para iterar várias vezes por meio do for loop. Sempre que o depurador pausar no ponto de interrupção, passe o mouse sobre a name variável e verifique o valor atual:

   

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

Inspecionar variáveis com as janelas Autos e Locais

Outra abordagem para inspecionar variáveis e valores é usando 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>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 as Diretrizes de Linguagem do Visual Studio.

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

   Se a janela não for exibida durante a sessão de depuração, selecione Depurar>Janelas>Locais para abrir a janela

3. Na janela Locais , expanda a letters variável 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.

Monitore uma variável

Se você estiver interessado em observar o comportamento de uma variável específica, poderá definir um relógio:

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

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

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 estiver em pausa no loop for, selecione a janela Call Stack para conferir a estrutura de chamada atual.

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

2. Pressione F11 (Depurar>Intervir) algumas vezes até que o depurador seja pausado no método SendMessage.

3. Olhe novamente para a janela Pilha de Chamadas:

   

   Na janela Pilha de Chamadas , a linha superior mostra a função atual (o SendMessage método neste aplicativo). A segunda linha mostra que o SendMessage método foi chamado do main método 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 a ser examinado pela depuração, mas não avança o depurador.
• Clique com o botão direito do mouse para acessar menus de elementos de programação na janela Pilha de Camadas. Por exemplo, você pode inserir pontos de interrupção em funções específicas, avançar o depurador usando Executar até o Cursor e navegar pelo código-fonte. Para saber mais, confira Exibir a pilha de chamadas e usar a janela Pilha de Chamadas no depurador.

Alterar o fluxo de execução

Outro recurso de depurador poderoso é a capacidade de modificar o fluxo de execução durante a depuração:

1. Selecione F11 (Depurar>Avançar para Dentro) duas vezes para executar a std::wcout função.

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 std::wcout função. 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. Ao selecionar a seta amarela, o Visual Studio exibe um aviso na dica de ferramentas indicando que a alteração na execução pode ter consequências inesperadas. 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.

Passar argumentos de linha de comando

Defina argumentos de linha de comando para seu aplicativo nas propriedades do projeto. Isso é útil quando você deseja testar como seu aplicativo se comporta com diferentes argumentos de linha de comando.

A partir do Visual Studio 2026, você pode definir argumentos de linha de comando para seu aplicativo na lista suspensa da barra de ferramentas de argumentos de linha de comando. Esse recurso está disponível para projetos do Visual Studio C++, projetos do Unreal Engine .uproject e projetos do CMake. Ele está atualmente em versão prévia e está sujeito a alterações antes do lançamento final.

Modifique o aplicativo para aceitar argumentos de linha de comando substituindo o código no get-started-debugging.cpp arquivo pelo seguinte:

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

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

int main(int argc, char* argv[])
{
    // Detect if the /u command-line argument was passed to the application.
    bool uppercase = false;
    for (int i = 1; i < argc; ++i)
    {
        if (std::string(argv[i]) == "/u")
        {
            uppercase = true;
            break;
        }
    }

    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;
        std::wstring nameToSend = name;

        if (uppercase) // Convert the name to uppercase if the /u argument was passed.
        {
            std::transform(nameToSend.begin(), nameToSend.end(), nameToSend.begin(), ::towupper);
        }
        SendMessage(nameToSend, a[i]);
    }
    return 0;
}

Essa versão atualizada do aplicativo aceita um argumento /u de linha de comando que converte o nome em maiúsculas antes de fazer a saída.

Para passar o /u argumento de linha de comando para o aplicativo quando você começar a depurá-lo, siga estas etapas:

1. Na barra de ferramentas Standard , caixa de texto argumentos de linha de comando, digite /u:

   

2. Coloque um ponto de interrupção na linha 19, uppercase = true;clicando na sarjeta esquerda nessa linha.

   

3. Comece a depurar seu aplicativo selecionando o botão Iniciar Depuração ou pressionando F5.

4. O depurador atinge o ponto de interrupção porque /u foi passado como um argumento de linha de comando:

   

5. Selecione F5 para continuar executando o aplicativo. A saída na janela do console mostra os nomes em maiúsculas agora:

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

Os argumentos de linha de comando são salvos na lista suspensa na ordem em que você os insere e aparecem na lista suspensa para uso futuro. Há um limite de cinco linhas de comando que você pode adicionar antes que a mais antiga seja removida para abrir espaço para a nova.

Você pode selecionar a seta de lista suspensa para ver uma lista de argumentos de linha de comando usados anteriormente.

Passar argumentos de linha de comando em diferentes tipos de projeto

A lista suspensa de argumentos de linha de comando contém uma opção específica de tipo de projeto para abrir a maneira clássica de definir os argumentos que o depurador passa para o programa. Para .vcxproj projetos, é por meio da página de propriedades de configurações do projeto. Para projetos do CMake, é editando o vs.launch.json arquivo. Para projetos do Mecanismo Unreal, é editando o .uproject arquivo.

Tipo de projeto do Visual Studio (.vcxproj)

Em um projeto do Visual Studio (.vcxproj), uma opção aparece na lista suspensa de argumentos de linha de comando para Editar em Páginas de Propriedades:

Selecione Editar em Páginas de Propriedades para abrir a janela de propriedades do projeto para a página de propriedades de depuração em que você define argumentos de linha de comando para passar ao depurar seu aplicativo:

As alterações nos Argumentos de Comando são refletidas na lista suspensa de argumentos de linha de comando para sessões futuras de depuração.

Tipo de projeto do CMake

Para projetos do CMake, uma opção aparece na lista suspensa de argumentos de linha de comando para Editar em launch.vs.json:

Selecione Editar launch.vs.json, para abrir o launch.vs.json arquivo e definir argumentos de linha de comando a serem passados ao depurar seu "args" aplicativo no elemento:

As alterações no arquivo são refletidas na lista suspensa de argumentos de linha de comando para sessões futuras de depuração.

Tipo de projeto do Mecanismo Unreal (.uproject)

Para projetos do Mecanismo Unreal, uma opção aparece na lista suspensa de argumentos de linha de comando para Editar em UETargetProperties.json:

Selecione Editar, para abrir o UETargetProperties.json arquivo que você define argumentos de linha de comando a serem passados ao depurar seu aplicativo no elemento "args":

As alterações no arquivo são refletidas na lista suspensa de argumentos de linha de comando para sessões futuras de depuração.

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)