Criar uma calculadora de console em C++

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

Pré-requisitos

• Visual Studio com o desenvolvimento Desktop com carga de trabalho 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, que permite que você faça alterações no seu código enquanto o aplicativo está em execução. Para ativar a edição e continuar, no menu principal, selecione Ferramentas>Opções>Depuração>Geral e verifique se a opção Exigir que os arquivos de origem correspondam exatamente à versão original está marcada.

Crie seu projeto de aplicativo

Visual Studio usa projetos para organizar o código para 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 do projeto e quaisquer arquivos externos. Para criar seu aplicativo, primeiro, crie um novo projeto e solução.

1. Iniciar o Visual Studio--a caixa de diálogo Iniciar 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 caixa de diálogo Criar um novo projeto , defina a lista suspensa de idioma como C++, defina a lista suspensa de plataforma como Windows, selecione Aplicativo de Console na lista de tipos de projeto e selecione Avançar.

   

   A lista suspensa de idioma é definida como C++, a lista suspensa de plataforma é definida como Windows e tipos de projeto como Projeto Vazio, Aplicativo de Console, Projeto CMake, Assistente de Área de Trabalho do Windows e assim por diante, aparecem na lista de tipos de projeto."

   Importante

   Certifique-se de selecionar a versão C++ do modelo Aplicativo de Console . Ele tem as tags C++, Windows e Console e 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' aplicativo é criado. Os aplicativos de console usam uma janela do 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
   

Verifique se o novo aplicativo é compilado e executado

O modelo para um novo aplicativo de console do Windows cria um aplicativo C++ simples "Hello World". Neste ponto, você pode ver como o Visual Studio cria e executa os aplicativos criados diretamente do IDE.

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

   

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

   

   Uma janela do console é aberta e seu aplicativo é executado dentro dela.

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

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

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

Agora você tem as ferramentas para criar e executar seu aplicativo após cada alteração, para verificar se o código ainda funciona como você espera. Mais tarde, mostraremos como depurá-lo se isso não acontecer.

Editar o código

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

1. Substitua o CalculatorTutorial.cpp conteúdo do arquivo 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
   

   Entendendo o código:

   • A #include instrução traz código em outros arquivos. Às vezes, você pode ver um nome de arquivo cercado por colchetes angulares como <iostream>. Os colchetes angulares instruem o compilador a procurar o iostream arquivo de cabeçalho primeiro nos diretórios padrão do sistema e, se não for encontrado, procurar em diretórios específicos para o projeto. Outras vezes, você pode ver um nome de arquivo cercado por aspas como "someHeader.h". As aspas instruem o compilador a pular a procura nos diretórios padrão do sistema e, em vez disso, procurar apenas em diretórios específicos para o projeto.
   • O using namespace std; diz ao compilador para esperar que o código da biblioteca padrão C++ seja usado neste arquivo. Sem esta linha, cada palavra-chave da biblioteca teria de ser precedida de std:: para indicar o seu âmbito. Por exemplo, sem essa linha, cada referência a cout seria escrita como std::cout. A using instrução é adicionada para tornar mais conveniente acessar o código em outro namespace.
   • A cout palavra-chave é usada para imprimir na saída padrão em C++. O << operador diz ao compilador para enviar o que estiver à direita dele para a saída padrão.
   • A endl palavra-chave é como a tecla Enter: termina a linha e move o cursor para a próxima linha. É uma prática melhor colocar um \n dentro da string (contida por "") para fazer a mesma coisa, porque endl sempre libera o buffer, o que pode prejudicar o desempenho do programa. Mas como este é um aplicativo muito pequeno, endl é usado em vez disso.
   • Todas as instruções C++ devem terminar com ponto-e-vírgula e todos os aplicativos C++ devem conter uma main() função. Esta função é o que o programa executa no início. Todo o código deve estar acessível a partir de main() para ser usado.

2. Para salvar o arquivo, pressione Ctrl+S ou selecione o ícone de disquete na barra de ferramentas na barra de menus.

3. Para executar o aplicativo, pressione Ctrl+F5 ou vá para o menu Depurar e selecione Iniciar sem Depuração. Deverá ver uma janela da consola a aparecer, com um aspeto semelhante a este.

4. Feche a janela do console quando terminar.

Adicionar código para fazer algumas contas

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

Adicionar uma classe de calculadora

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

   

   O campo de nome da classe contém a calculadora de texto. 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. As opções para inline e Managed estão desmarcadas.

   Dois novos arquivos são adicionados ao seu projeto. Para salvar todos os arquivos alterados de uma só vez, pressione Ctrl+Shift+S. É um atalho de teclado para Ficheiro>Guardar Tudo. Há também um botão da barra de ferramentas para Salvar tudo, um ícone de dois disquetes, encontrado ao lado do botão Salvar . Em geral, é uma boa prática fazer Salvar tudo com frequência, para que você não deixe de salvar nenhuma alteração.

   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, abra-a a partir da barra de menus através da Vista do>Explorador de Soluções.

   

   O projeto tutorial da calculadora tem um nó de arquivos de cabeçalho contendo o Calculator.h. Um nó Arquivos de código-fonte 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 do Calculator.h pelo código a seguir 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 lida com 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 arquivos de origem (.cpp). Algumas outras extensões de arquivo são suportadas por vários compiladores, mas estes são os principais a saber. Funções e variáveis são normalmente declaradas, isto é, dado um nome e um tipo, em arquivos de cabeçalho, e implementadas, ou dadas uma definição, em arquivos de origem. Para acessar o código definido em outro arquivo, você pode usar #include "filename.h", onde 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 diferentes arquivos com base no que ele faz, para que seja fácil encontrar o código de que você precisa mais tarde. No nosso caso, definimos a Calculator classe separadamente do ficheiro que contém a main() função, mas planeamos referenciar a Calculator classe em main().

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

   

   Este código é adicionado a Calculator.cpp:

   

   A definição da função é: calculadora dupla::Calculate( double x, char oper, double y) { return 0.0; }

   Atualmente, retorna apenas 0.0. Vamos encriptá-los.

4. Mude para o arquivo Calculator.cpp na janela do editor. Substitua o conteúdo do 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 leva um número, um operador e um segundo número. Em seguida, ele executa a operação solicitada nos dois números.
   • A switch instrução verifica qual operador foi fornecido e executa o caso correspondente a essa operação. O default: caso serve como um fallback para o caso de o utilizador digitar um operador que não é tratado por nenhuma das instruções anteriores case. É melhor lidar com a entrada inválida do usuário de uma maneira mais elegante, mas isso está além do escopo deste tutorial.
   • A double palavra-chave indica um tipo de número que suporta decimais. Este tipo de número é chamado de número de vírgula flutuante e double significa um número de ponto flutuante que tem precisão extra. Desta forma, a calculadora pode lidar com matemática decimal e matemática inteira. A Calculate função é necessária para sempre retornar um número de ponto flutuante de precisão dupla devido ao double no início do código (isso denota o tipo de retorno da função), e é por isso que retornamos 0.0 no caso padrão.
   • O .h arquivo declara o protótipo da função, que informa ao compilador antecipadamente quais parâmetros ele requer e qual tipo de retorno esperar dele. O .cpp arquivo tem todos os detalhes de implementação da função.

Se você compilar e executar o código novamente neste ponto, ele será encerrado imediatamente depois de 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 função main em CalculatorTutorial.cpp da seguinte forma:

   // 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

   • Como os programas C++ começam sempre na função main(), precisamos chamar o nosso outro código a partir daí, por isso é necessária uma instrução #include para tornar esse código visível para a nossa função main().
   • As variáveis 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 Calculator c; linha declara um objeto nomeado c como uma instância da Calculator classe. A aula em si é apenas um modelo de como as calculadoras funcionam; O objeto é a calculadora específica que faz as contas.
   • A while (true) instrução é um loop. O código dentro do loop é executado repetidamente, enquanto a condição dentro do () for verdadeira. Como a condição é simplesmente listada como true, é sempre verdade, então o loop é executado para sempre. Para fechar o programa, o usuário deve fechar manualmente a janela do console. Caso contrário, o programa sempre aguarda por novas entradas.
   • A cin palavra-chave aceita a entrada do usuário. O 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.
   • A c.Calculate(x, oper, y); expressão chama a Calculate função definida anteriormente e fornece os valores de entrada inseridos e a operação solicitada. Em seguida, a função retorna um número armazenado no result.
   • Finalmente, result é impresso no console e o usuário vê o resultado do cálculo.

Crie e teste o código novamente

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

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

2. Digite 5+5e pressione Enter. Verifique se o resultado é 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

3. Pare o programa fechando a janela do console.

Depurar o aplicativo

Como o utilizador tem liberdade 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.

Corra a aplicação no depurador

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

   

   Agora, quando depuramos o programa, a execução pausa nessa linha. Já temos uma ideia aproximada 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 da condição, digite (y == 0) && (oper == '/'). Selecione o botão Fechar para salvar a condição de ponto de interrupção.

   

   O ponto de interrupção está na linha: resultado = c ponto Calcular ( x, oper, y). «Condições...» A opção Condição está marcada. O menu suspenso Condições está definido para "Expressão condicional". A lista suspensa de condições é definida como "É verdadeiro". A condição é definida como y == 0 && oper == '/'.

   Agora, a execução pausa no ponto de interrupção quando o aplicativo tenta dividir por 0.

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

   

Janelas úteis no depurador

Ao depurar o seu código, pode reparar que aparecem novas janelas. Essas janelas podem melhorar 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. Se você não vir a janela Autos , no menu principal, selecione Depurar>Windows>Autos.

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

Para ver todas as variáveis dessa função, alterne para a janela Locais . Como esta é uma função pequena, a janela Autos e Locais mostra as mesmas variáveis. Mas você pode modificar os valores dessas variáveis na janela Locais durante a depuração para ver o efeito que elas teriam no programa. Neste caso, deixamo-los em paz. Abra a janela Locais selecionando Locais na parte inferior da janela Automáticos ou selecionando no menu principal Depurar>Locais do>.

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

Você também pode passar o mouse sobre variáveis no código para ver seus valores atuais no ponto em que a execução está pausada no momento. Certifique-se de que 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 chama Calculate, então pressione F11 para entrar na função. Agora você está executando código no corpo da Calculate função. Tenha cuidado com o Step Into porque ele entra em todas as funções na linha em que você está, incluindo funções padrão da biblioteca. É 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 Calculate função, pressione F10 para passar para a próxima linha na execução do programa. F10 também é conhecido como Step Over. Você pode usar Step Over para mover de linha em linha, sem se aprofundar 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 mergulhar mais profundamente no código que está sendo chamado de outro lugar (como fez para chegar ao corpo do Calculate).

3. Continue usando F10 para avançar cada linha até voltar para a main() função no outro ficheiro e parar na cout linha.

   O programa está fazendo o que se espera: pega o primeiro número e o divide pelo segundo. Na cout linha, passe o mouse sobre a result variável ou dê uma olhada no result na janela Autos. Seu valor é inf, o que não parece certo.

   

   A instrução atual no depurador é cout << "Result is: " << result << endl; Na janela autos, o resultado é inf.

   Vamos corrigi-lo. A cout linha produz qualquer valor armazenado no result, portanto, quando você avança mais uma linha usando F10, a janela do console exibe:

   

   O aplicativo indica: Insira a operação a realizar. Formato: a+b | a-b | a*b | a/b. O utilizador introduziu 5-0. A saída da aplicação: 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 tem uma resposta numérica para a operação solicitada.

Corrigir o erro "dividir por zero"

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

1. Faça as seguintes alterações no CalculatorTutorial.cpp. Você pode deixar o programa em execução enquanto edita, graças a um recurso de 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 é 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 << "Math error: 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é que ele tenha que pausar para solicitar a entrada do usuário. Entre 10 / 0 novamente. Agora, uma mensagem mais útil é impressa. O utilizador é solicitado a fornecer mais informações, e o programa continua a executar-se normalmente.

   

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

   Observação

   Quando você edita o código enquanto está no modo de depuração, há um risco de o código ficar obsoleto. Isso acontece quando o depurador ainda está executando seu código antigo e ainda não o atualizou com suas alterações. O depurador exibe uma janela de diálogo para informar quando isso acontecer. Às vezes, talvez seja 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 dessa função, você precisa sair da função e, em seguida, voltar para ela novamente 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, comece a depuração novamente digitando F5 ou escolhendo a seta verde "play" ao lado do botão de parada na barra de ferramentas.

   Outra razão pela qual editar e continuar pode falhar é se você vir uma mensagem que diz "A configuração Exigir que os arquivos de origem correspondam exatamente à versão original em Debug-Options-General>> precisa ser habilitada..." Para corrigir isso, no menu principal, selecione Ferramentas>Opções>Depuração>Geral e verifique se a opção Exigir que os arquivos de origem correspondam exatamente à versão original está marcada.

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

   • F5, ou Debug>Start Debugging, inicia uma sessão de depuração, se ainda não estiver ativa, e executa o programa até que um ponto de interrupção seja atingido ou o programa precise da 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 se fechará quando o programa terminar de ser executado. Se o programa for enviado para o console, use Ctrl+F5 ou defina um ponto de interrupção antes de pressionar F5 para manter a janela aberta.
   • Ctrl+F5, ou Debug>Start Without Debugging, 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 permanece aberta depois de o programa terminar de ser executado.
   • F10, conhecido como Step Over, permite iterar através do código, linha por linha, e visualizar como o código é executado e quais valores de variáveis estão em cada etapa de execução.
   • F11, conhecido como Step Into, funciona de forma semelhante ao Step Over, exceto que entra em quaisquer funções chamadas na linha de execução. Por exemplo, se a linha que está sendo executada chamar uma função, pressionar F11 move o ponteiro para o corpo da função, para que você possa seguir o código da função que está sendo executado antes de voltar para a linha em que você começou. Pressionando F10 executa a chamada de função e apenas se move para a próxima linha; a chamada da função ainda ocorre, mas o programa não pausa para mostrar o que está a fazer.

Fechar a aplicação

• Se ainda estiver em execução, feche a janela do console para parar o aplicativo da calculadora.

Adicionar controle de origem do Git

Agora que você criou um aplicativo, talvez queira adicioná-lo a um repositório Git. Nós tratamos disso. O Visual Studio facilita esse processo com as ferramentas Git que você pode usar diretamente do IDE.

Sugestão

O Git é o sistema de controle de versão moderno mais utilizado, 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 lugar para começar. Lá, você pode encontrar cheat sheets, um livro online popular e vídeos do Git Basics.

Para associar seu código ao Git, você começa criando um novo repositório Git onde seu código está localizado. Veja como:

1. Na barra de status no canto inferior direito do Visual Studio, selecione Adicionar ao controle do código-fonte e, em seguida, selecione Git.

   

2. Na caixa de diálogo Criar um repositório Git , faça login no GitHub.

   

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

   Sugestão

   Quer seu repositório seja público ou privado, é melhor ter um backup remoto do seu 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 Enviar.

   Depois de criar o repositório, os detalhes de status aparecem na barra de status.

   

   O primeiro ícone com as setas mostra o número de commits de saída/entrada na sua branch atual. Você pode usar este ícone para puxar quaisquer confirmações de entrada ou enviar quaisquer confirmações de saída. Você também pode optar por visualizar esses commits primeiro. Para fazer isso, selecione o ícone e, em seguida, selecione Exibir saída/entrada.

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

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

A aplicação concluída

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

Próximos passos

Saiba mais sobre o Visual Studio para C++