Tworzenie kalkulatora konsoli w języku C++

Zwykle punktem wyjścia dla programisty języka C++ jest aplikacja "Hello, world!", która działa w wierszu polecenia. Zacznij od tego w tym artykule, a następnie przejdź do czegoś trudniejszego: aplikacji kalkulatora.

Wymagania wstępne

• Program Visual Studio z zainstalowanym i uruchomionym na komputerze obciążeniem Programowanie aplikacji klasycznych C++. Aby go zainstalować, zobacz Instalowanie obsługi języka C++ w programie Visual Studio.
• W tym samouczku przedstawiono funkcję o nazwie edytuj i kontynuuj, która umożliwia wprowadzanie zmian w kodzie podczas działania aplikacji. Aby włączyć edycję i kontynuować, w menu głównym wybierz pozycję Narzędzia>Opcje>Debugowanie>ogólne i upewnij się, że opcja Wymagaj plików źródłowych do dokładnego dopasowania oryginalnej wersji jest zaznaczona.

Tworzenie projektu aplikacji

Program Visual Studio używa projektów do organizowania kodu dla aplikacji i rozwiązań w celu organizowania co najmniej jednego projektu. Projekt zawiera wszystkie opcje, konfiguracje i reguły używane do tworzenia aplikacji. Zarządza również relacją między wszystkimi plikami projektu i plikami zewnętrznymi. Aby utworzyć aplikację, najpierw utwórz nowy projekt i rozwiązanie.

1. Uruchom program Visual Studio — zostanie wyświetlone okno dialogowe Uruchamianie programu Visual Studio. Wybierz pozycję Utwórz nowy projekt , aby rozpocząć pracę.

   

   Okno dialogowe zawiera opcje klonowania repozytorium, otwierania projektu lub rozwiązania, otwierania folderu lokalnego i tworzenia nowego projektu".

2. W oknie dialogowym Tworzenie nowego projektu ustaw listę rozwijaną języka C++, ustaw listę rozwijaną platformy na Windows, wybierz pozycję Aplikacja konsolowa z listy typów projektów, a następnie wybierz pozycję Dalej.

   

   Lista rozwijana języka jest ustawiona na C++, lista rozwijana platformy jest ustawiona na Windows, a typy projektów, takie jak Pusty projekt, Aplikacja konsolowa, Projekt CMake, Kreator pulpitu systemu Windows itd., są wyświetlane na liście typów projektów.

   Ważne

   Upewnij się, że wybrano wersję języka C++ szablonu Aplikacja konsolowa . Ma tagi C++, Windows i Console , a ikona ma "++" w rogu.

3. W oknie dialogowym Konfigurowanie nowego projektu wybierz pole tekstowe Nazwa projektu , nadaj nowemu projektowi nazwę CalculatorTutorial, a następnie wybierz pozycję Utwórz.

   

   Zostanie utworzona pusta aplikacja konsolowa systemu Windows w języku C++ "Hello World". Aplikacje konsolowe używają okna konsoli systemu Windows do wyświetlania danych wyjściowych i akceptowania danych wejściowych użytkownika. W programie Visual Studio zostanie otwarte okno edytora z wyświetlonym wygenerowanym kodem:

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

Zweryfikuj, czy Twoja nowa aplikacja się kompiluje i uruchamia

Szablon nowej aplikacji konsolowej systemu Windows tworzy prostą aplikację "Hello World" w języku C++. W tym momencie możesz zobaczyć, jak program Visual Studio kompiluje i uruchamia aplikacje tworzone bezpośrednio ze środowiska IDE.

1. Aby skompilować projekt, wybierz pozycję Kompiluj rozwiązanie z menu Kompilacja . W oknie Dane wyjściowe są wyświetlane wyniki procesu kompilacji.

   

2. Aby uruchomić kod, na pasku menu wybierz pozycję Debuguj>start bez debugowania (Ctrl+F5).

   

   Zostanie otwarte okno konsoli i aplikacja zostanie uruchomiona w niej.

   Po uruchomieniu aplikacji konsolowej w programie Visual Studio aplikacja uruchamia twój kod, a następnie wyświetli komunikat "Naciśnij dowolny klawisz, aby zamknąć to okno." . aby dać Ci szansę zobaczenia wyników.

   Gratulacje! Utworzono pierwszą aplikację konsolową "Hello, world!" w programie Visual Studio!

3. Naciśnij, aby zamknąć okno konsoli i wrócić do programu Visual Studio.

Teraz masz narzędzia do kompilowania i uruchamiania aplikacji po każdej zmianie, aby sprawdzić, czy kod nadal działa zgodnie z oczekiwaniami. Później pokażemy, jak rozwiązywać problemy, jeśli coś nie działa.

Edytowanie kodu

Teraz zmodyfikujmy kod w tym szablonie tak, aby był aplikacją kalkulatora.

1. Zastąp zawartość CalculatorTutorial.cpp pliku następującym kodem, tak aby był zgodny z tym przykładem:

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

   Opis kodu:

   • Instrukcja #include wprowadza kod w innych plikach. Czasami może zostać wyświetlona nazwa pliku otoczona nawiasami kątowymi, takimi jak <iostream>. Nawiasy kątowe instruują kompilatorowi, aby najpierw wyszukał plik nagłówka iostream w standardowych katalogach systemowych, a jeśli nie znaleziono, w katalogach specyficznych dla projektu. Innym razem może zostać wyświetlona nazwa pliku otoczona cudzysłowami, takimi jak "someHeader.h". Cudzysłowy instruują kompilator, aby pominął wyszukiwanie w standardowych katalogach systemowych i zamiast tego wyszukiwać tylko w katalogach specyficznych dla projektu.
   • Polecenie using namespace std; nakazuje kompilatorowi oczekiwać użycia kodu z standardowej biblioteki języka C++ w tym pliku. Bez tego wiersza każde słowo kluczowe z biblioteki musi być poprzedzone std:: , aby oznaczyć jego zakres. Na przykład bez tego wiersza każde odwołanie cout do zostanie zapisane jako std::cout. Instrukcja using jest dodawana, aby ułatwić dostęp do kodu w innej przestrzeni nazw.
   • Słowo kluczowe cout służy do wyświetlania na standardowe wyjście w języku C++. Operator << nakazuje kompilatorowi wysłanie wszystkiego, co znajduje się po jego prawej stronie, do standardowego wyjścia.
   • Słowo kluczowe jest podobne do endl Enter; kończy wiersz i przenosi kursor do następnego wiersza. Lepszym rozwiązaniem jest umieszczenie \n wewnątrz ciągu (zawartego przez "") w celu wykonania tej samej czynności, ponieważ endl zawsze opróżnia bufor, który może zaszkodzić wydajności programu. Ale ponieważ jest to bardzo mała aplikacja, endl jest używana zamiast tego.
   • Wszystkie instrukcje języka C++ muszą kończyć się średnikami, a wszystkie aplikacje języka C++ muszą zawierać main() funkcję. Ta funkcja jest uruchamiana przez program na początku. Cały kod musi być dostępny z main(), aby można go było używać.

2. Aby zapisać plik, naciśnij Ctrl+S lub wybierz ikonę dyskietki na pasku narzędzi na pasku menu.

3. Aby uruchomić aplikację, naciśnij Ctrl+F5 lub przejdź do menu Debugowanie i wybierz pozycję Rozpocznij bez debugowania. Powinno zostać wyświetlone okno konsoli, które wygląda następująco.

4. Po zakończeniu zamknij okno konsoli.

Dodawanie kodu w celu wykonania pewnych obliczeń matematycznych

Klasa jest jak strategia dla obiektu, który coś robi. W tym przypadku zdefiniujemy klasę kalkulatora zawierającą logikę matematyczną.

Dodawanie klasy Kalkulator

1. Przejdź do menu Project (Projekt ) i wybierz pozycję Add Class (Dodaj klasę). W polu Edycja nazwy klasy wprowadź Kalkulator. Kliknij przycisk OK.

   

   Pole nazwy klasy zawiera kalkulator tekstu. Pole pliku .h zawiera plik Calculator.h. Pole pliku .cpp zawiera Calculator.cpp. Pole klasy bazowej jest puste. Opcje liniowe i Zarządzane są niezaznaczone.

   Dwa nowe pliki są dodawane do projektu. Aby zapisać wszystkie zmienione pliki jednocześnie, naciśnij Ctrl+Shift+S. Jest to skrót klawiaturowy dla Plik>Zapisz wszystko. Na pasku narzędzi znajduje się również przycisk Zapisz wszystko, oznaczony ikoną dwóch dyskietek, umieszczony obok przycisku Zapisz. Ogólnie rzecz biorąc, dobrym rozwiązaniem jest częste korzystanie z opcji Zapisz wszystko, aby nie przegapić zapisania żadnych zmian.

   Kreator Dodawania klasy tworzy pliki .h oraz .cpp o tej samej nazwie co klasa. Pełną listę plików projektu można wyświetlić w oknie Eksplorator rozwiązań widocznym po stronie środowiska IDE. Jeśli okno nie jest widoczne, otwórz je z paska menu za pomocą opcji Wyświetl>Eksplorator rozwiązań.

   

   Projekt samouczka kalkulatora zawiera sekcję plików nagłówkowych, w której znajduje się plik Calculator.h. Węzeł Pliki źródłowe zawiera Calculator.cpp i CalculatorTutorial.cpp. Węzły dla odwołań, zależności zewnętrznych i plików zasobów są widoczne, ale zamknięte.

   Plik można otworzyć, klikając go dwukrotnie w oknie Eksplorator rozwiązań . Kliknij dwukrotnie Calculator.h, aby go otworzyć.

2. Zastąp zawartość Calculator.h następującym kodem, tak aby plik wyglądał następująco:

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

   Omówienie kodu

   • Ten kod deklaruje nową funkcję o nazwie Calculate, która obsługuje operacje matematyczne na potrzeby dodawania, odejmowania, mnożenia i dzielenia.
   • Kod C++ jest zorganizowany w pliki nagłówkowe (.h) i pliki źródłowe (.cpp). Niektóre inne rozszerzenia plików są obsługiwane przez różne kompilatory, ale są to główne rozszerzenia, o których warto wiedzieć. Funkcje i zmienne są zwykle deklarowane, czyli nadane nazwę i typ, w plikach nagłówkowych i zaimplementowane, lub podane definicje, w plikach źródłowych. Aby uzyskać dostęp do kodu zdefiniowanego w innym pliku, możesz użyć polecenia #include "filename.h", gdzie filename.h jest nazwą pliku, który deklaruje zmienne lub funkcje, których chcesz użyć.
   • Dobrym rozwiązaniem jest zorganizowanie kodu w różne pliki w oparciu o to, co robi, dzięki czemu można łatwo znaleźć potrzebny kod później. W naszym przypadku definiujemy klasę Calculator oddzielnie od pliku zawierającego funkcję main(), ale planujemy odwołać się do klasy Calculator w main().

3. Zielona fala pojawia się pod Calculate, ponieważ mimo że funkcja Calculate jest zadeklarowana, nie jest zdefiniowana. Najedź kursorem na Calculate, kliknij strzałkę w dół na ikonie śrubokręta, a następnie wybierz Utwórz definicję "Oblicz" w Calculator.cpp.

   

   Ten kod jest dodawany do elementu Calculator.cpp:

   

   Definicja funkcji to: double Calculator::Calculate( double x, char oper, double y) { return 0.0; }

   Obecnie zwraca tylko wartość 0,0. Zmieńmy to.

4. Przejdź do pliku Calculator.cpp w oknie edytora. Zastąp zawartość elementu: Calculator::Calculate(double x, char oper, double y)

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

   Omówienie kodu

   • Funkcja Calculate przyjmuje liczbę, operator i drugą liczbę. Następnie wykonuje żądaną operację na dwóch liczbach.
   • Instrukcja switch sprawdza, który operator został podany, i wykonuje przypadek odpowiadający tej operacji. Przypadek default: jest rezerwowym w sytuacji, gdy użytkownik wpisze operator, który nie jest obsługiwany przez żadną z poprzednich case instrukcji. Najlepiej jest obsługiwać nieprawidłowe dane wejściowe użytkownika w bardziej elegancki sposób, ale wykracza to poza zakres tego samouczka.
   • Słowo double kluczowe określa typ liczby, która obsługuje liczby dziesiętne. Ten typ liczby jest nazywany liczbą zmiennoprzecinkową i double oznacza liczbę zmiennoprzecinkową, która ma dodatkową precyzję. Dzięki temu kalkulator może obsługiwać zarówno matematykę dziesiętną, jak i liczbę całkowitą. Funkcja Calculate jest wymagana, aby zawsze zwracać liczbę zmiennoprzecinkową o podwójnej precyzji ze względu na double znajdujące się na początku kodu (oznacza to typ zwracany przez funkcję), dlatego zwracamy wartość 0,0 w domyślnym przypadku.
   • Plik .h deklaruje prototyp funkcji, który informuje kompilator z góry, jakich parametrów wymaga, i jakiego typu zwrotu oczekiwać od niego. Plik .cpp zawiera wszystkie szczegóły implementacji funkcji.

Jeśli w tym momencie skompilujesz i uruchomisz kod ponownie, natychmiast zakończy się po wywołaniu operacji do wykonania. Zmodyfikuj funkcję main , aby wykonywać wiele obliczeń.

Wywoływanie Calculator funkcji składowych klasy

1. Zaktualizuj funkcję main w CalculatorTutorial.cpp jak poniżej:

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

   Omówienie kodu

   • Ponieważ programy języka C++ zawsze zaczynają się od main() funkcji, musimy wywołać nasz inny kod z tego miejsca, więc #include instrukcja jest wymagana, aby ten kod był widoczny dla naszej main() funkcji.
   • Zmienne x, , yoperi result są zadeklarowane do przechowywania pierwszej liczby, drugiej liczby, operatora i wyniku końcowego odpowiednio. Zawsze dobrym rozwiązaniem jest nadanie im pewnych początkowych wartości, aby uniknąć niezdefiniowanego zachowania, co jest wykonywane tutaj.
   • Wiersz Calculator c; deklaruje obiekt o nazwie c jako wystąpienie Calculator klasy. Sama klasa jest tylko strategią sposobu działania kalkulatorów; obiekt jest konkretnym kalkulatorem, który wykonuje obliczenia matematyczne.
   • Instrukcja while (true) jest pętlą. Kod wewnątrz pętli jest wykonywany ponownie, o ile warunek w obiekcie () ma wartość true. Ponieważ warunek jest po prostu wymieniony jako true, jest zawsze prawdziwy, więc pętla jest uruchamiana na zawsze. Aby zamknąć program, użytkownik musi ręcznie zamknąć okno konsoli. W przeciwnym razie program zawsze czeka na nowe dane wejściowe.
   • Słowo cin kluczowe akceptuje dane wejściowe od użytkownika. Strumień wejściowy jest wystarczająco inteligentny, aby przetworzyć wiersz tekstu wprowadzony w oknie konsoli i umieścić go wewnątrz każdej z wymienionych zmiennych w kolejności.
   • Wyrażenie c.Calculate(x, oper, y); wywołuje zdefiniowaną Calculate wcześniej funkcję i dostarcza wprowadzone wartości wejściowe i żądaną operację. Następnie funkcja zwraca liczbę przechowywaną w pliku result.
   • Na koniec result zostanie wydrukowany na konsolę, a użytkownik zobaczy wynik obliczenia.

Ponownie skompiluj i przetestuj kod

Teraz ponownie przetestuj program, aby upewnić się, że wszystko działa prawidłowo.

1. Naciśnij Ctrl+F5 , aby ponownie skompilować i uruchomić aplikację.

2. Wprowadź 5+5, a następnie naciśnij Enter. Sprawdź, czy wynik to 10.

   

   Aplikacja wyświetli komunikat: Wprowadź operację do wykonania. Format: a+b | a-b | a*b | a/b. Użytkownik wprowadził wartość 5+5. Dane wyjściowe aplikacji: wynik 5+5: 10

3. Zatrzymaj program, zamykając okno konsoli.

Debugowanie aplikacji

Ponieważ użytkownik może wpisać dowolne dane w oknie konsoli, upewnij się, że kalkulator obsługuje nieoczekiwane dane wejściowe. Zamiast uruchamiać program, zdebubujmy go, abyśmy mogli sprawdzić, co robi krok po kroku.

Uruchamianie aplikacji w debugerze

1. W CalcuatorTutorial.cpp, ustaw punkt przerwania na linii: result = c.Calculate(x, oper, y);. Aby ustawić punkt przerwania, kliknij obok wiersza na szarym pasku pionowym wzdłuż lewej krawędzi okna edytora, aby pojawić się czerwona kropka.

   

   Teraz, gdy debugujemy program, wykonywanie jest wstrzymywane w tym wierszu. Mamy już ogólne pojęcie, że program działa w prostych przypadkach. Ponieważ nie chcemy wstrzymywać wykonywania za każdym razem, gdy wywołujemy Calculate(), zróbmy warunkowy punkt przerwania.

2. Kliknij prawym przyciskiem myszy czerwoną kropkę reprezentującą punkt przerwania, a następnie wybierz pozycję Warunki. W polu edycji warunku wprowadź (y == 0) && (oper == '/'). Wybierz przycisk Zamknij , aby zapisać warunek punktu przerwania.

   

   Punkt przerwania znajduje się w wierszu: result = c dot Calculate ( x, oper, y). "Warunki..." Opcja Warunek jest zaznaczona. Lista rozwijana Warunki jest ustawiona na "Wyrażenie warunkowe". Lista rozwijana warunku jest ustawiona na wartość "Is true". Warunek jest ustawiony na y == 0 && oper == '/'.

   Teraz wykonanie zatrzymuje się na punkcie przerwania, gdy aplikacja próbuje podzielić przez 0.

3. Aby debugować program, naciśnij F5 lub wybierz przycisk paska narzędzi debugera lokalnego debugera systemu Windows z zieloną strzałką. Jeśli w aplikacji konsolowej wprowadzisz wartość podobną do "5–0", program zachowuje się normalnie i działa. Jednak jeśli wpiszesz "10 / 0", wykonanie zatrzymuje się w punkcie przerwania. Można umieścić dowolną liczbę spacji między operatorem a liczbami: cin jest wystarczająco inteligentna, aby odpowiednio przeanalizować dane wejściowe.

   

Przydatne okna w debugerze

Podczas debugowania kodu można zauważyć, że pojawią się nowe okna. Te okna mogą pomóc w debugowaniu. Zajrzyj do okna Auto. W oknie Autos są wyświetlane bieżące wartości zmiennych używanych co najmniej trzy wiersze wcześniej, aż do bieżącego wiersza. Jeśli nie widzisz okna Autos, z menu głównego wybierz pozycję Debug>Okna>Autos.

Wartość oper to 47 '/', wynik to 5, x to 10, a y to 0.

Aby wyświetlić wszystkie zmienne z tej funkcji, przejdź do okna Ustawienia lokalne . Ponieważ jest to mała funkcja, w oknie Autos i Locals są wyświetlane te same zmienne. Można jednak zmodyfikować wartości tych zmiennych w oknie Ustawienia lokalne podczas debugowania, aby zobaczyć, jaki wpływ miałoby to na program. W tym przypadku pozostawiamy je w spokoju. Otwórz okno Ustawienia lokalne, wybierając pozycję Lokalne w dolnej części okna Autos lub wybierając z menu głównego pozycję Debuguj>ustawienia lokalne systemu>.

Wartość oper wynosi 47, '/', wynik to 0, x to 10, a y to 0.

Możesz również umieścić wskaźnik myszy na zmiennych w kodzie, aby zobaczyć ich bieżące wartości w punkcie, w którym wykonywanie jest obecnie wstrzymane. Upewnij się, że okno edytora jest w centrum uwagi, klikając go najpierw.

Kontynuuj debugowanie

1. Żółta strzałka po lewej stronie pokazuje bieżący punkt wykonywania. Bieżący wiersz wywołuje funkcję Calculate, więc należy nacisnąć F11, aby Wejść do funkcji. Teraz wykonujesz kod wewnątrz funkcji Calculate. Uważaj na Step Into, ponieważ przechodzi do wszystkich funkcji w linii, w tym funkcji standardowych bibliotek. Warto przejść do standardowej biblioteki, ale być może bardziej interesuje Cię skupienie się na kodzie zamiast kodu biblioteki.

2. Teraz, gdy punkt startu wykonania znajduje się na początku funkcji Calculate, naciśnij F10, aby przejść do następnego wiersza w wykonywaniu programu. F10 jest również znany jako Step Over. Wiersza do wiersza możesz używać Step Over, aby przechodzić bez zagłębiania się w szczegóły tego, co dzieje się w każdej części wiersza. Ogólnie rzecz biorąc, powinieneś używać Step Over zamiast Step Into, chyba że chcesz się bardziej wgłębić w kod wywoływany z innego miejsca (jak to zrobiłeś, aby dotrzeć do treści Calculate).

3. Kontynuuj używanie F10, aby Przejść nad każdą linią, dopóki nie wrócisz do funkcji w main() innym pliku i zatrzymaj się na cout linii.

   Program robi to, czego oczekuje się: przyjmuje pierwszą liczbę i dzieli ją przez drugą. cout W wierszu umieść kursor nad zmienną result lub przyjrzyj się w result oknie Autos. Jego wartość to inf, która nie wygląda prawidłowo.

   

   Bieżąca instrukcja w debugerze to cout << "Result is: " << result << endl; W oknie automatycznym wynik jest inf.

   Naprawmy to. Wiersz cout wyświetla wartość przechowywaną w result, więc po przejściu o jeden wiersz do przodu za pomocą F10 okno konsoli wyświetli:

   

   Komunikat aplikacji: Proszę wprowadzić operację do wykonania. Format: a+b | a-b | a*b | a/b. Użytkownik wprowadził wartość 5-0. Dane wyjściowe aplikacji: Wynik: 5. Użytkownik wprowadził 10/0. Dane wyjściowe aplikacji: Wynik: inf

   Jest to spowodowane tym, że dzielenie według zera jest niezdefiniowane, więc program nie ma liczbowej odpowiedzi dla żądanej operacji.

Napraw błąd "dzielenia przez zero"

Obsłużmy dzielenie przez zero bardziej przejrzyście, aby ułatwić użytkownikowi zrozumienie problemu.

1. Wprowadź następujące zmiany w pliku CalculatorTutorial.cpp. Możesz pozostawić program uruchomiony podczas edycji, dzięki funkcji debugera o nazwie Edytuj i Kontynuuj. Dodaj instrukcję if poniżej cin >> x >> oper >> y; , aby sprawdzić podział według zera i wyświetlić komunikat do użytkownika, jeśli tak się stanie. W przeciwnym razie zostanie wydrukowany wynik.

   // 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. Naciśnij F5 raz. Wykonywanie programu będzie kontynuowane, dopóki nie zostanie wstrzymane, aby poprosić o podanie danych wejściowych użytkownika. Wprowadź 10 / 0 ponownie. Teraz zostanie wydrukowany bardziej pomocny komunikat. Użytkownik jest proszony o więcej danych wejściowych, a program kontynuuje normalne wykonywanie.

   

   W oknie konsoli są wyświetlane dwa wiersze: 10/0 Wynik: inf, a następnie 10/0 Błąd matematyczny: Podjęto próbę podzielenia przez zero.

   Uwaga / Notatka

   Podczas edytowania kodu w trybie debugowania istnieje ryzyko, że kod staje się nieaktualny. Dzieje się tak, gdy debuger nadal uruchamia stary kod i nie zaktualizował go wraz ze zmianami. Debuger wyświetla okno dialogowe informujące o tym, kiedy tak się stanie. Czasami może być konieczne naciśnięcie F5 , aby odświeżyć wykonywany kod. W szczególności, jeśli wprowadzisz zmianę wewnątrz funkcji, gdy punkt wykonywania znajduje się wewnątrz tej funkcji, musisz wyjść z funkcji, a następnie wrócić do niej ponownie, aby uzyskać zaktualizowany kod. Jeśli to nie zadziała i zostanie wyświetlony komunikat o błędzie, możesz zatrzymać debugowanie, klikając czerwony kwadrat na pasku narzędzi w menu w górnej części środowiska IDE, a następnie ponownie rozpocznij debugowanie, wprowadzając F5 lub wybierając zieloną strzałkę "odtwórz" obok przycisku zatrzymania na pasku narzędzi.

   Innym powodem, dla którego funkcja edycji i kontynuacji może się nie udać, jest wyświetlenie komunikatu: "Ustawienie Wymagaj plików źródłowych do dokładnego dopasowania do wersji oryginalnej w obszarze Debug-Opcje-Ogólne musi być włączone..." Aby to naprawić, wybierz w menu głównym pozycję >>Opcje>Debugowanie>Ogólne i upewnij się, że opcja > jest zaznaczona.

   Opis skrótów Uruchamiania i debugowania

   • F5, lub Debuguj>rozpocznij debugowanie, uruchamia sesję debugowania, jeśli jeszcze nie jest aktywna, i uruchamia program do momentu trafienia punktu przerwania lub gdy program potrzebuje danych wejściowych użytkownika. Jeśli żadne dane wejściowe użytkownika nie są potrzebne i żaden punkt przerwania nie jest dostępny, program zakończy działanie, a okno konsoli zostanie zamknięte po zakończeniu działania programu. Jeśli program wyprowadza dane wyjściowe do konsoli, użyj Ctrl+F5 lub ustaw punkt przerwania przed naciśnięciem F5 , aby zachować otwarte okno.
   • Ctrl+F5 lub Debuguj>rozpocznij bez debugowania, uruchamia aplikację bez przechodzenia do trybu debugowania. Jest to nieco szybsze niż debugowanie, a okno konsoli pozostaje otwarte po zakończeniu wykonywania programu.
   • F10, znany jako Step Over, umożliwia iterowanie przez kod, wiersz po wierszu i wizualizowanie sposobu uruchamiania kodu oraz wartości zmiennych w każdym kroku wykonywania.
   • F11, znany jako Krok do środka, działa podobnie do Krok nad, z wyjątkiem wchodzenia do jakichkolwiek funkcji wywoływanych w wierszu wykonywania. Na przykład, jeśli wykonywany wiersz wywołuje funkcję, naciśnięcie F11 przenosi wskaźnik do wnętrza funkcji, dzięki czemu można śledzić wykonywanie jej kodu przed powrotem do pierwotnego wiersza. Naciśnięcie F10 pomija wywołanie funkcji i przechodzi do następnej linii; wywołanie funkcji nadal się odbywa, ale program nie zatrzymuje się, aby pokazać, co robi.

Zamykanie aplikacji

• Jeśli nadal działa, zamknij okno konsoli, aby zatrzymać aplikację kalkulatora.

Dodaj kontrolę źródła Git

Po utworzeniu aplikacji możesz dodać ją do repozytorium Git. Pomożemy Ci. Program Visual Studio ułatwia ten proces za pomocą narzędzi Git, których można używać bezpośrednio ze środowiska IDE.

Wskazówka

Git to najczęściej używany nowoczesny system kontroli wersji, więc niezależnie od tego, czy jesteś profesjonalnym deweloperem, czy uczysz się kodować, usługa Git może być bardzo przydatna. Jeśli dopiero zaczynasz pracę z usługą Git, witryna internetowa https://git-scm.com/ jest dobrym miejscem do rozpoczęcia. Tam można znaleźć ściągawki, popularną książkę online i filmy Git Basics.

Aby skojarzyć kod z usługą Git, zacznij od utworzenia nowego repozytorium Git, w którym znajduje się kod. Oto, jak to zrobić:

1. Na pasku stanu w prawym dolnym rogu programu Visual Studio wybierz pozycję Dodaj do kontroli źródła, a następnie wybierz pozycję Git.

   

2. W oknie dialogowym Tworzenie repozytorium Git zaloguj się do usługi GitHub.

   

   Nazwa repozytorium jest wypełniana automatycznie na podstawie lokalizacji folderu. Domyślnie nowe repozytorium jest prywatne, co oznacza, że jesteś jedynym, który może uzyskać do niego dostęp.

   Wskazówka

   Niezależnie od tego, czy repozytorium jest publiczne, czy prywatne, najlepiej mieć zdalną kopię zapasową kodu przechowywanego bezpiecznie w usłudze GitHub. Nawet jeśli nie pracujesz z zespołem, repozytorium zdalne udostępnia ci kod z dowolnego komputera.

3. Wybierz Utwórz i wypchnij.

   Po utworzeniu repozytorium na pasku stanu zostaną wyświetlone szczegóły stanu.

   

   Pierwsza ikona ze strzałkami pokazuje liczbę zatwierdzeń wychodzących/przychodzących w bieżącej gałęzi. Możesz użyć tej ikony, aby pobrać zatwierdzenia przychodzące lub wysłać zatwierdzenia wychodzące. Możesz również najpierw wyświetlić te zatwierdzenia. W tym celu wybierz ikonę, a następnie wybierz pozycję Wyświetl wychodzące/przychodzące.

   Druga ikona z ołówkiem pokazuje liczbę niezatwierdzonych zmian w kodzie. Możesz wybrać tę ikonę, aby wyświetlić te zmiany w oknie Git Changes.

Aby dowiedzieć się więcej na temat korzystania z usługi Git z aplikacją, zobacz dokumentację kontroli wersji programu Visual Studio.

Zakończona aplikacja

Gratulacje! Ukończono kod aplikacji kalkulatora, skompilowany i debugowany oraz dodano go do repozytorium — wszystko w programie Visual Studio.

Dalsze kroki

Dowiedz się więcej o programie Visual Studio dla języka C++