Criar uma calculadora de console em C++

O ponto de partida usual para um programador do C++ é um aplicativo "Olá, mundo!" que é executado na linha de comando. Você começará com isso neste artigo e, em seguida, passaremos para algo mais desafiador: um aplicativo de calculadora.

Pré-requisitos

• Visual Studio com a carga de trabalho de desenvolvimento Desktop com C++ instalada e em execução no seu computador. Para instalá-lo, consulte Instalar suporte a C++ no Visual Studio.
• Este tutorial demonstra um recurso chamado editar e continuar, o que permite que você faça alterações no código enquanto o aplicativo está em execução. Para habilitar a edição e continuar, no menu principal, selecione Ferramentas>Opções>Depuração>Geral e verifique se a opção Exigir arquivos de origem para corresponder exatamente à versão original está marcada.

Criar seu projeto de aplicativo

Visual Studio usa projetos para organizar o código de um aplicativo e soluções para organizar um ou mais projetos. Um projeto contém todas as opções, configurações e regras usadas para criar um aplicativo. Ele também gerencia a relação entre todos os arquivos de projeto e todos os arquivos externos. Para criar seu aplicativo, primeiro crie um projeto e uma solução.

1. Inicie o Visual Studio--a caixa de diálogo Início do Visual Studio é exibida. Selecione Criar um novo projeto para começar.

   

   A caixa de diálogo tem opções para clonar um repositório, abrir um projeto ou solução, abrir uma pasta local e criar um novo projeto."

2. Na lista de modelos de projeto, selecione Aplicativo de Console e selecione Avançar.

   

   Importante

   Certifique-se de selecionar a versão C++ do modelo Aplicativo de Console. Ele tem as marcas C++, Windows e Console, enquanto o ícone tem "++" no canto.

3. Na caixa de diálogo Configurar seu novo projeto, selecione a caixa de texto Nome do projeto, nomeie seu novo projeto como CalculatorTutorial e selecione Criar.

   

   Um aplicativo de console do Windows C++ vazio 'Hello World' é criado. Os aplicativos de console usam uma janela de console do Windows para exibir a saída e aceitar a entrada do usuário. No Visual Studio, uma janela do editor é aberta e mostra o código gerado:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   int main()
   {
       std::cout << "Hello World!\n";
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

Verificar se o novo aplicativo compila e executa

O modelo para um novo aplicativo de console do Windows cria um aplicativo simples "Olá, Mundo" em C++. Neste ponto, você pode ver como o Visual Studio compila e executa os aplicativos que você cria diretamente no IDE.

1. Para compilar seu projeto, selecione Compilar solução no menu Compilar . A janela de Saída mostra os resultados do processo de build.

   

2. Para executar o código, na barra de menus, selecione Depurar, Iniciar sem depuração (Ctrl+F5).

   

   Uma janela do console é aberta e, em seguida, executa seu aplicativo.

   Quando você inicia um aplicativo de console no Visual Studio, ele é executado em seu código e, em seguida, imprime "Pressione qualquer tecla para fechar esta janela. . ." para lhe dar a oportunidade de ver a saída.

   Parabéns! Você criou seu primeiro aplicativo de console "Olá, mundo!" no Visual Studio!

3. Pressione uma tecla para ignorar a janela do console e retornar ao Visual Studio.

Agora você tem as ferramentas para compilar e executar seu aplicativo após cada alteração para verificar se o código ainda funciona conforme o esperado. Posteriormente, mostraremos como depurá-lo se ele não funcionar bem.

Editar o código

Agora vamos modificar o código neste modelo para ser um aplicativo de calculadora.

1. Substitua o conteúdo do arquivo CalculatorTutorial.cpp pelo código a seguir para que ele corresponda a este exemplo:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   
   using namespace std;
   
   int main()
   {
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
           << endl;
       return 0;
   }
   
   // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
   // Debug program: F5 or Debug > Start Debugging menu
   // Tips for Getting Started:
   //   1. Use the Solution Explorer window to add/manage files
   //   2. Use the Team Explorer window to connect to source control
   //   3. Use the Output window to see build output and other messages
   //   4. Use the Error List window to view errors
   //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
   //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
   

   Noções básicas sobre o código:

   • As instruções #include permitem que você consulte a código localizado em outros arquivos. Às vezes, você poderá ver um nome de arquivo delimitado por colchetes angulares (<>); outras vezes, entre aspas (" "). Em geral, os colchetes angulares são usados ao fazer referência à biblioteca padrão C++, enquanto as aspas são usadas para outros arquivos.
   • A linha using namespace std; informa ao compilador para esperar que coisas da Biblioteca Padrão C++ sejam usadas nesse arquivo. Sem essa linha, cada palavra-chave da biblioteca precisaria ser precedida por std:: para indicar seu escopo. Por exemplo, sem essa linha, cada referência a cout precisaria ser escrito como std::cout. A instrução using é adicionada para fazer com que o código tenha uma aparência mais limpa.
   • A palavra-chave cout é usada para imprimir a saída padrão em C++. O operador << informa ao compilador para enviar o que estiver à direita para a saída padrão.
   • A palavra-chave endl é como a tecla Enter; encerra a linha e move o cursor para a próxima linha. É uma prática melhor colocar um \n dentro da string (contido por "") para fazer a mesma coisa, porque endl sempre libera o buffer, o que pode prejudicar o desempenho do programa. Como esse é um aplicativo muito pequeno, o endl é usado para melhorar a legibilidade.
   • Todas as instruções C++ devem terminar com ponto e vírgula e todos os aplicativos C++ devem conter uma função main(). Essa função é o que o programa é executado no início. Todo o código deve estar acessível de main() para ser usado.

2. Para salvar o arquivo, pressione Ctrl+S ou selecione o ícone Salvar próximo à parte superior do IDE, o ícone de disquete na barra de ferramentas sob a barra de menus.

3. Para executar o aplicativo, pressione Ctrl+F5 ou vá para o menu Depurar e selecione Iniciar sem Depurar. Você deve ver uma janela do console em exibição com o texto especificado no código.

4. Feche a janela do console ao terminar.

Adicionar código para fazer alguns cálculos matemáticos

Uma classe é como um blueprint para um objeto que faz algo. Nesse caso, definimos uma classe de calculadora para conter a lógica matemática.

Adicionar uma classe Calculator

1. Vá para o menu Projeto e selecione Adicionar classe. Na caixa de edição Nome de Classe, digite Calculadora. Selecione OK.

   

   O campo de nome da classe é definido como calculadora. O campo de arquivo .h contém Calculator.h. O campo de arquivo .cpp contém Calculator.cpp. O campo de classe base está vazio. Outras opções para destruidor virtual, embutido e não gerenciado estão desmarcadas.

   Dois novos arquivos são adicionados ao seu projeto. Para salvar todos os arquivos alterados de uma vez, pressione Ctrl+Shift+S. É um atalho de teclado para Arquivo>Salvar Tudo. Também há um botão de barra de ferramentas para Salvar Tudo, um ícone de dois disquetes, encontrado ao lado do botão Salvar. Em geral, é uma boa prática executar Salvar Tudo com frequência, para que você não perca nenhum arquivo ao salvar.

   O assistente Adicionar classe cria .h e .cpp arquivos que têm o mesmo nome que a classe. Você pode ver uma lista completa de seus arquivos de projeto na janela Gerenciador de Soluções visível na lateral do IDE. Se a janela não estiver visível, você poderá abri-la na barra de menus: selecione Exibir>Gerenciador de Soluções.

   

   O projeto tutorial da calculadora tem um nó de arquivos de cabeçalho contendo Calculator.h. Um nó Arquivos de Origem contém Calculator.cpp e CalculatorTutorial.cpp. Os nós para referências, dependências externas e arquivos de recursos são visíveis, mas fechados.

   Você pode abrir um arquivo clicando duas vezes nele na janela Gerenciador de Soluções. Clique duas vezes Calculator.h para abri-lo.

2. Substitua o conteúdo de Calculator.h pelo seguinte código para que o arquivo agora tenha esta aparência:

   #pragma once
   class Calculator
   {
   public:
       double Calculate(double x, char oper, double y);
   };
   

   Compreender o código

   • Este código declara uma nova função chamada Calculate, que usamos para executar operações matemáticas para adição, subtração, multiplicação e divisão.
   • O código C++ é organizado em arquivos de cabeçalho (.h) e origem (.cpp). Várias outras extensões de arquivo têm suporte pelos vários compiladores, mas estes são os principais conhecer. Funções e variáveis normalmente são declaradas, ou seja, recebem um nome e um tipo, nos arquivos de cabeçalho, e implementadas ou recebem uma definição nos arquivos de origem. Para acessar código definido em outro arquivo, você poderá usar #include "filename.h", em que filename.h é o nome do arquivo que declara as variáveis ou funções que você deseja usar.
   • É uma boa prática organizar seu código em arquivos diferentes com base no que ele faz, de modo que seja fácil encontrar o código de que você precisa mais tarde. Em nosso caso, definimos a classe Calculator separadamente do arquivo que contém a função main(), mas podemos planejar fazer referência à classe Calculator em main().

3. Um rabisco verde aparece abaixo Calculate porque, embora a Calculate função seja declarada, ela não está definida. Passe o mouse sobre Calculate, clique na seta para baixo na chave de fenda que aparece e selecione Criar definição de 'Calcular' no Calculator.cpp.

   

   Este código é adicionado a Calculator.cpp:

   

   A definição do construtor é: double Calculator::Calculate( double x, char oper, double y) { return 0.0; }

   Atualmente, retorna apenas 0,0. Vamos mudar isso.

4. Alterne para o arquivo Calculator.cpp na janela do editor. Substitua o conteúdo de Calculator::Calculate(double x, char oper, double y) por:

   double Calculator::Calculate(double x, char oper, double y)
   {
       switch(oper)
       {
           case '+':
               return x + y;
           case '-':
               return x - y;
           case '*':
               return x * y;
           case '/':
               return x / y;
           default:
               return 0.0;
       }
   }
   

   Compreender o código

   • A função Calculate consome um número, um operador e um segundo número e, em seguida, executa a operação solicitada nos números.
   • A instrução de opção verifica que operador foi fornecido e somente executa o caso que corresponde a essa operação. O padrão: caso é uma contingência se o usuário digita um operador que não é aceito, de modo que o programa não seja interrompido. Em geral, é melhor manipular uma entrada de usuário inválida de uma maneira mais elegante, mas isso está além do escopo deste tutorial.
   • A palavra-chave double denota um tipo de número que dá suporte a decimais. Dessa forma, a calculadora pode lidar com matemática decimal e de inteiros. A função Calculate é necessária para sempre retornar esse número devido ao double bem no início do código (isso denota o tipo de retorno da função), e é por isso que devemos retornar 0,0 até mesmo no caso padrão.
   • O arquivo .h declara a função protótipo, que informa ao compilador antecipadamente quais parâmetros são necessários e que tipo de retorno esperar dele. O arquivo .cpp tem todos os detalhes de implementação da função.

Se você compilar e executar o código novamente neste ponto, ele será imediatamente encerrado após perguntar qual operação executar. Então, modifique a main função para fazer vários cálculos.

Chamar as funções de membro da Calculator classe

1. Atualize a main função da CalculatorTutorial.cpp seguinte maneira:

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
            << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           result = c.Calculate(x, oper, y);
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

   Compreender o código

   • Uma vez que os programas C++ sempre começam com a função main(), precisamos chamar o outro código daí, portanto, uma instrução #include é necessária.
   • Algumas variáveis iniciais x, y, oper e result são declaradas para armazenar o primeiro número, o segundo número, o operador e o resultado final, respectivamente. É sempre uma boa prática dar-lhes alguns valores iniciais para evitar comportamentos indefinidos, que é o que é feito aqui.
   • A linha Calculator c; declara um objeto chamado 'c' como uma instância da classe Calculator. A classe em si é apenas o blueprint para como as calculadoras funcionam; o objeto é a calculadora específica que faz os cálculos.
   • A instrução while (true) é um loop. O código dentro do loop continua sendo executado repetidamente enquanto a condição em () se aplicar. Uma vez que a condição é simplesmente listada como true, ela é sempre verdadeira, portanto, o loop é executado indefinidamente. Para fechar o programa, o usuário deve fechar manualmente a janela do console. Caso contrário, o programa sempre esperará a nova entrada.
   • A palavra-chave cin é usada para aceitar a entrada do usuário. Esse fluxo de entrada é inteligente o suficiente para processar uma linha de texto inserida na janela do console e colocá-la dentro de cada uma das variáveis listadas, em ordem, supondo que a entrada do usuário corresponda à especificação necessária. Você pode modificar essa linha para aceitar diferentes tipos de entrada, como mais de dois números, embora a função Calculate() também precise ser atualizada para lidar com isso.
   • A expressão c.Calculate(x, oper, y); chama a função Calculate definida anteriormente e fornece os valores de entrada inseridos. A função retorna um número que é armazenado em result.
   • Por fim, result é impresso no console para que o usuário veja o resultado do cálculo.

Compilar e testar o código novamente

Agora teste o programa novamente para se certificar de que tudo funciona corretamente.

1. Pressione Ctrl+F5 para recompilar e iniciar o aplicativo.

2. Insira 5+5 e pressione Enter. Verifique se o resultado será 10.

   

   O aplicativo emite a mensagem: Insira a operação a ser executada. Formato: a+b | A-B | a*b | a/b. O usuário digitou 5+5. A saída do aplicativo: Resultado de 5+5 é: 10

Depurar o aplicativo

Como o usuário é livre para digitar qualquer coisa na janela do console, vamos garantir que a calculadora lide com entradas inesperadas. Em vez de executar o programa, vamos depurá-lo para que possamos inspecionar o que ele está fazendo passo a passo.

Executar o aplicativo no depurador

1. No CalcuatorTutorial.cpp, defina um ponto de interrupção na linha: result = c.Calculate(x, oper, y);. Para definir um ponto de interrupção, clique Para fazer isso, clique ao lado da linha na barra vertical cinza ao longo da borda esquerda da janela do editor. Um ponto vermelho é exibido.

   

   Agora, quando depuramos o programa, a execução pausa nessa linha. Já temos uma ideia superficial de que o programa funciona para casos simples. Como não queremos pausar a execução toda vez que ligamos Calculate(), vamos condicionar o ponto de interrupção.

2. Clique com o botão direito do mouse no ponto vermelho que representa o ponto de interrupção e selecione Condições. Na caixa de edição para a condição, insira (y == 0) && (oper == '/'). Selecione o botão Fechar para salvar a condição do ponto de interrupção.

   

   A condição para o ponto de interrupção é: y==0 && oper == '/' É verdadeiro.

   Agora, a execução será pausada no ponto de interrupção quando o aplicativo tentar dividir por 0.

3. Para depurar o programa, pressione F5 ou selecione o botão da barra de ferramentas Depurador Local do Windows que tem o ícone de seta verde. Em seu aplicativo de console, se você digitar algo como "0-5", o programa se comportará normalmente e continuará em execução. No entanto, se você digitar "10 / 0", ele fará uma pausa no ponto de interrupção. Você pode colocar qualquer número de espaços entre o operador e os números: cin é inteligente o suficiente para analisar a entrada adequadamente.

   

Janelas úteis no depurador

Quando você depurar seu código, você pode notar que algumas novas janelas aparecem. Essas janelas podem ajudar a sua experiência de depuração. Dê uma olhada na janela Autos. A janela Autos mostra os valores atuais das variáveis usadas pelo menos três linhas antes e até a linha atual.

O valor de oper é 47 '/', o resultado é 5, x é 10 e y é 0.

Para ver todas as variáveis dessa função, alterne para a janela Locais. Você pode modificar os valores dessas variáveis durante a depuração para ver o efeito que elas teriam no programa. Neste caso, deixamos de lado.

O valor de oper é 47 '/', o resultado é 0, x é 10 e y é 0.

Você também pode passar o mouse sobre as variáveis no código para ver seus valores atuais no ponto em que a execução está pausada no momento. Verifique se a janela do editor está em foco clicando nela primeiro.

Continuar a depuração

1. A seta amarela à esquerda mostra o ponto atual de execução. A linha atual que chama Calculate, assim, pressione F11 para Depurar a função. Agora você está executando o código no corpo da função Calculate. Tenha cuidado com o Step Into porque ele entra em todas as funções na linha em que você está, incluindo funções de biblioteca padrão. É bom entrar na biblioteca padrão, mas você pode estar mais interessado em se concentrar em seu código em vez de código de biblioteca.

2. Agora que o ponto de execução está no início da função Calculate, pressione F10 para ir para a próxima linha na execução do programa. F10 também é conhecido como Depuração Parcial. Você pode usar Depuração Parcial para mover de uma linha para outra, sem aprofundar-se nos detalhes do que está ocorrendo em cada parte da linha. Em geral, você deve usar Step Over em vez de Step Into, a menos que queira aprofundar-se no código que está sendo chamado de outro lugar (como você fez para alcançar o corpo de Calculate).

3. Continue usando F10 para realizar a Depuração Parcial de cada linha até que você voltar para a função main() no outro arquivo e pare na linha cout.

   O programa está fazendo o que é esperado: pega o primeiro número e divide pelo segundo. Na linha cout, focalize a variável result ou dê uma olhada result na janela Autos. Seu valor inf, que não parece certo. Vamos corrigir. A linha cout somente gera qualquer valor que esteja armazenado em result, portanto, quando você avança mais uma linha usando F10, a janela do console exibe:

   

   A saída do aplicativo: Insira a operação a ser executada. Formato: a+b | A-B | a*b | a/b. O usuário fez 5 a 0. A saída do aplicativo: O resultado é: 5. O usuário digitou 10/0. A saída do aplicativo: O resultado é: inf

   Esse resultado ocorre porque a divisão por zero é indefinida, de modo que o programa não possui uma resposta numérica para a operação solicitada.

Corrigir o erro de "divisão por zero"

Vamos lidar com a divisão por zero mais normalmente para que seja mais fácil para o usuário entender o problema.

1. Faça as seguintes alterações em CalculatorTutorial.cpp. (Você pode deixar o programa em execução durante a edição, graças a um recurso do depurador chamado Editar e Continuar). Adicione uma if instrução a seguir cin >> x >> oper >> y; para verificar a divisão por zero e envie uma mensagem para o usuário se isso acontecer. Caso contrário, o resultado será impresso.

   // CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends there.
   //
   
   #include <iostream>
   #include "Calculator.h"
   
   using namespace std;
   
   int main()
   {
       double x = 0.0;
       double y = 0.0;
       double result = 0.0;
       char oper = '+';
   
       cout << "Calculator Console Application" << endl << endl;
       cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b" << endl;
   
       Calculator c;
       while (true)
       {
           cin >> x >> oper >> y;
           if (oper == '/' && y == 0)
           {
               cout << "Attempted to divide by zero!" << endl;
               continue;
           }
           else
           {
               result = c.Calculate(x, oper, y);
           }
           cout << "Result " << "of " << x << oper << y << " is: " << result << endl;
       }
   
       return 0;
   }
   

2. Pressione F5 uma vez. A execução do programa continua até ele precisar pausar para pedir entrada do usuário. Insira 10 / 0 novamente. Agora, é impressa uma mensagem mais útil. O usuário é solicitado a fornecer mais entradas e o programa continua em execução normalmente.

   

   A janela do console exibe duas linhas: 10 / 0 O resultado é: inf, seguido de, 10 / 0 Erro matemático: Tentativa de dividir por zero.

   Observação

   Quando você edita o código no modo de depuração, há um risco de o código se tornar obsoleto. Isso acontece quando o depurador ainda está executando seu código antigo e não ainda o atualizou com suas alterações. O depurador exibe uma caixa de diálogo para informá-lo quando isso acontece. Às vezes, pode ser necessário pressionar F5 para atualizar o código que está sendo executado. Em particular, se você fizer uma alteração dentro de uma função enquanto o ponto de execução está dentro daquela função, precisará sair da função e voltar para ela para obter o código atualizado. Se isso não funcionar e você vir uma mensagem de erro, você pode parar a depuração clicando no quadrado vermelho na barra de ferramentas sob os menus na parte superior do IDE, em seguida, começar a depuração novamente digitando F5 ou escolhendo a seta verde "play" ao lado do botão parar na barra de ferramentas.

   Outra razão pela qual a edição e a continuação podem falhar é se você vir uma mensagem que diz "A configuração Exigir arquivos de origem para corresponder exatamente à versão original em Debug-Options-General>> precisa ser habilitada..." Para corrigir isso, no menu principal, selecione Ferramentas>Opções>de depuração Geral e certifique-se>de que Exigir arquivos de origem para corresponder exatamente à versão original esteja marcado.

   Noções básicas sobre os atalhos de Executar e Depurar

   • F5 (ou Depurar>Iniciar Depuração) iniciará uma sessão de depuração se uma ainda não estiver ativa e executará o programa até atingir um ponto de interrupção ou o programa precisar de entrada do usuário. Se nenhuma entrada do usuário for necessária e nenhum ponto de interrupção estiver disponível para ser atingido, o programa será encerrado e a janela do console fechará mesmo quando o programa for encerrado. Se você tiver algo parecido com um programa "Olá, Mundo" para ser executado, use CTRL+F5 ou defina um ponto de interrupção antes de pressionar F5 para manter a janela aberta.
   • CTRL + F5 (ou Depurar>Iniciar sem Depuração) executa o aplicativo sem entrar no modo de depuração. Isso é um pouco mais rápido do que a depuração e a janela do console permaneça aberta depois de o programa terminar a execução.
   • F10 (conhecido como Depuração Parcial) permite que você itere pelo código linha por linha e visualize como o código é executado e quais valores de variáveis estão em cada etapa de execução.
   • F11 (conhecido como Depurar) funciona da mesma forma que Depuração Parcial, exceto que depura todas as funções chamadas na linha de execução. Por exemplo, se a linha que está sendo executada chamar uma função, pressionar F11 moverá o ponteiro para o corpo da função, de modo que você possa seguir o código da função que está em execução antes de voltar para a linha em que começou. Pressionar F10 faz a depuração parcial da chamada de função e apenas se move para a próxima linha; a chamada de função ainda acontece, mas o programa não pausa para mostrar o você está fazendo.

Feche o aplicativo

• Se ele ainda estiver em execução, feche a janela de console para o aplicativo de calculadora.

Adicionar o controle do código-fonte do Git

Agora que você criou um aplicativo, pode ser interessante adicioná-lo a um repositório Git. Nós podemos ajudar. O Visual Studio facilita esse processo com as ferramentas de Git que você pode usar diretamente no IDE.

Dica

O Git é o sistema de controle de versão moderno mais usado, portanto, se você é um desenvolvedor profissional ou está aprendendo a codificar, o Git pode ser muito útil. Se você é novo no Git, o site https://git-scm.com/ é um bom local para começar. Lá você vai encontrar roteiros, um livro online popular e vídeos de Conceitos Básicos do Git.

Para associar seu código ao Git, comece criando um repositório Git no local em que seu código está localizado. Aqui está como:

1. Na barra de status no canto inferior direito do Visual Studio, selecione Adicionar ao Controle do Código-Fonte e selecione Git.

   

2. Na caixa de diálogo Criar um repositório Git, entre no GitHub.

   

   O nome do repositório é preenchido automaticamente com base no local da sua pasta. Por padrão, o novo repositório é privado, o que significa que você é o único que pode acessá-lo.

   Dica

   Não importa se o repositório é público ou privado, é melhor ter um backup remoto do código armazenado com segurança no GitHub. Mesmo que você não esteja trabalhando com uma equipe, um repositório remoto disponibiliza seu código para você em qualquer computador.

3. Selecione Criar e Efetuar Push.

   Depois de criar o repositório, os detalhes do status aparecerão na barra de status.

   

   O primeiro ícone com as setas mostra quantos commits de saída/entrada estão no branch atual. Você pode usar esse ícone para efetuar pull de qualquer commit de entrada ou efetuar push de commits de saída. Você também pode optar por exibir primeiro esses commits. Para fazer isso, selecione o ícone e selecione Exibir Saída/Entrada.

   O segundo ícone com o lápis mostra o número de alterações não confirmadas no código. Você pode selecionar este ícone para exibir essas alterações na janela Alterações do Git.

Para saber mais sobre como usar o Git com seu aplicativo, veja a documentação de controle de versão do Visual Studio.

O aplicativo finalizado

Parabéns! Você concluiu o código do aplicativo de calculadora, o compilou e o depurou e o adicionou a um repositório, tudo no Visual Studio.

Próximas etapas

Saiba mais sobre o Visual Studio para C++