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

Neste tutorial, você depurar um aplicativo C++ usando o depurador do Visual Studio. 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 instruções para passar pelo código no depurador
• Inspecionar variáveis em informações de dados e janelas do depurador
• Examine a pilha de chamadas
• Definir argumentos de linha de comando para seu aplicativo

Se és novo na depuração, poderás querer ler Depuração para iniciantes absolutos antes de iniciares este tutorial. Se pretender uma visão mais abrangente dos recursos do depurador, consulte Primeiro olhar sobre o 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 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 (Ficheiro>Janela de Início), 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 Aplicação Consola, pode instalá-lo a partir da 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 seu novo aplicativo. Escolha a localização padrão ou navegue para um caminho diferente no 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 get-started-debugging.cpp arquivo é 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;
}

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 get-started-debugging.cpp arquivo no editor de código e localize o formain loop da 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]; 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.

   Sugestão

   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 um dos recursos fundamentais e essenciais para uma 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 poderoso do depurador é a capacidade de modificar o fluxo de execução durante a depuração:

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.

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 Visual Studio C++, projetos Unreal Engine .uproject e projetos CMake. Está atualmente em pré-visualização 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;
}

Esta versão atualizada do aplicativo aceita um argumento /u de linha de comando que converte o nome em maiúsculas antes de enviá-lo.

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

1. Na barra de ferramentas Padrão , caixa de texto Argumentos da linha de comando , digite /u:

   

2. Coloque um ponto de interrupção na linha 19, uppercase = true;clicando na calha 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 são inseridos 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 da 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 seu programa. Para .vcxproj projetos, é através da página de propriedades de configurações do projeto. Para projetos CMake, é editando o vs.launch.json arquivo. Para projetos Unreal Engine é 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 Depuração , onde 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 futuras sessões de depuração.

Tipo de projeto CMake

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

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

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

Tipo de projeto Unreal Engine (.uproject)

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

Selecione Editar em UETargetProperties.json, para abrir o arquivo onde você define argumentos UETargetProperties.json de linha de comando para passar 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 futuras sessões 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)