Erstellen eines Konsolenrechners in C++

Der übliche Ausgangspunkt für C++-Programmierer*innen ist eine Hallo-Welt-Anwendung, die über die Befehlszeile ausgeführt wird. Eine solche Anwendung erstellen Sie mithilfe dieses Artikels in Visual Studio. Anschließend beschäftigen Sie sich mit einer etwas schwierigeren Aufgabe: der Erstellung einer Taschenrechner-App.

Voraussetzungen

• Visual Studio mit der Workload Desktopentwicklung mit C++ muss auf Ihrem Computer installiert sein und ausgeführt werden. Ist dies noch nicht der Fall, finden Sie unter Install C++ support in Visual Studio (Installieren von C++-Komponenten in Visual Studio) weitere Informationen.
• In diesem Tutorial wird ein Feature namens „Bearbeiten und Fortfahren“ veranschaulicht, mit dem Sie Änderungen am Code vornehmen können, während die App ausgeführt wird. Um sicherzustellen, dass „Bearbeiten und Fortfahren“ für diesen Artikel funktionieren kann, wählen Sie im Hauptmenü Extras>Optionen>Debuggen>Allgemein aus, und stellen Sie sicher, dass Quelldateien müssen exakt mit der Originalversion übereinstimmen aktiviert ist.

Erstellen Ihres App-Projekts

Visual Studio verwendet Projekte, um Code für eine App zu ordnen, und Projektmappen, um Ihre Projekte zu ordnen. Ein Projekt beinhaltet alle Optionen, Einstellungen und Regeln, die Sie zum Erstellen Ihrer Anwendung verwendet haben. Es verwaltet auch die Beziehungen zwischen allen Projektdateien und externen Dateien. Erstellen Sie zunächst ein neues Projekt und eine Projektmappe, um ihre Anwendung zu erstellen.

1. Wenn Sie Visual Studio gestartet haben, wird das Startdialogfeld für Visual Studio angezeigt. Klicken Sie auf Neues Projekt erstellen, um zu beginnen.

   

   Alternativ können Sie auch in der Menüleiste in Visual Studio Datei>Neu>Projekt aufrufen. Dadurch wird das Fenster Neues Projekt erstellen geöffnet.

2. Wählen Sie in der Liste der Projektvorlagen Konsolen-App aus, und klicken Sie anschließend auf Weiter.

   

   Wichtig

   Wählen Sie die C++-Version der Vorlage Konsolen-App aus. Diese erkennen Sie an den Tags C++ , Windows und Konsole, und das Symbol enthält „++“ in der Ecke.

3. Klicken Sie im Dialogfeld Neues Projekt konfigurieren in das Feld Projektname, und geben Sie dort den Namen CalculatorTutorial für das neue Projekt ein. Klicken Sie anschließend auf Erstellen.

   

   Eine leere C++-Windows-Konsolenanwendung wird erstellt. Konsolenanwendungen verwenden ein Windows-Konsolenfenster, um Ausgabe anzuzeigen und Benutzereingaben entgegenzunehmen. In Visual Studio wird ein Editorfenster geöffnet und der generierte Code angezeigt:

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

Überprüfen, dass Ihre neue App erstellt und ausgeführt wird

Die Vorlage für eine neue Windows-Konsolenanwendung erstellt eine einfache „Hallo Welt“-App in C++. An diesem Punkt können Sie sehen, wie die Apps, die Sie direkt in der IDE erstellen, in Visual Studio erstellt und ausgeführt werden.

1. Wählen Sie zum Erstellen Ihres Projekts aus dem Menü Erstellen die Option Projektmappe erstellen aus. Im Fenster Ausgabe wird das Ergebnis des Erstellungsprozess angezeigt.

   

2. Klicken Sie zum Ausführen des Codes auf der Menüleiste auf Debuggen > Ohne Debuggen starten.

   

   Ein Konsolenfenster wird geöffnet, und Ihre App daraufhin ausgeführt. Wenn Sie eine Konsolen-App in Visual Studio starten, führt diese Ihren Code aus und gibt dann „Press any key to close this window.“ (Drücken Sie eine beliebige Taste, um dieses Fenster zu schließen.) aus. . Dies gibt Ihnen die Möglichkeit, sich die Ausgabe anzusehen. Herzlichen Glückwunsch! Sie haben Ihre erste Hallo-Welt-Konsolen-App in Visual Studio erstellt.

3. Drücken Sie eine Taste, um das Konsolenfenster zu schließen, und kehren Sie zu Visual Studio zurück.

Sie haben nun die Tools, um Ihre App nach jeder Änderung zu erstellen und auszuführen, um zu überprüfen, ob der Code noch so funktioniert, wie Sie es erwarten. Später erhalten Sie Informationen zum Debuggen, wenn Ihr Code nicht funktioniert.

Bearbeiten des Codes

Wandeln Sie den Code in dieser Vorlage nun in eine Rechner-App um.

1. Ersetzen Sie den Inhalt der Datei CalculatorTutorial.cpp durch den folgenden Code, damit er diesem Beispiel entspricht:

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

   Grundlegendes zum Code:

   • Die #include-Anweisungen ermöglichen es Ihnen, auf Code zu verweisen, der sich in anderen Dateien befindet. Manchmal kommt es vor, dass Sie einen Dateinamen sehen, der von spitzen Klammern (<>) eingeschlossen wird, manchmal wird er von Anführungszeichen (" ") eingeschlossen. Generell werden spitze Klammern verwendet, wenn auf die C++-Standardbibliothek verwiesen wird, während Anführungszeichen für andere Dateien verwendet werden.
   • Die using namespace std;-Zeile sagt dem Compiler, dass dieser Inhalt aus der C++-Standardbibliothek zu erwarten hat, der in dieser Datei verwendet werden soll. Ohne diese Zeile müsste jedem Schlüsselwort aus der Bibliothek std:: vorangestellt werden, um dessen Bereich zu bezeichnen. Ohne diese Zeile müsste beispielsweise jeder Verweis auf cout als std::cout geschrieben werden. Die using-Anweisung wird hinzugefügt, um den Code übersichtlicher zu gestalten.
   • Das Schlüsselwort cout wird verwendet, damit die Standardausgabe in C++ erfolgt. Der Operator << sagt dem Compiler, dass dieser alles, was rechts von ihm steht, an die Standardausgabe senden soll.
   • Das Schlüsselwort endl ist ähnlich wie die Eingabetaste. Es beendet die Zeile und lässt den Cursor in die nächste Zeile springen. Es hat sich aber noch mehr bewährt, innerhalb der Zeichenfolge mit demselben Effekt ein \n-Zeichen zu setzen (eingeschlossen von ""), da endl den Puffer immer leert, was die Leistung des Programms beeinträchtigen kann. Da es sich hier jedoch um eine sehr kleine App handelt, wird endl stattdessen zur besseren Lesbarkeit verwendet.
   • Alle C++-Anweisungen müssen mit einem Semikolon enden, und alle C++-Anwendungen müssen eine main()-Funktion enthalten. Diese Funktion wird vom Programm zuerst ausgeführt. Die Funktion main() muss auf den ganzen Code zugreifen können, damit dieser verwendet werden kann.

2. Wenn Sie die Datei speichern möchten, drücken Sie STRG+S, oder klicken Sie im oberen Bereich der IDE auf das Speichern-Symbol: das Diskettensymbol in der Symbolleiste unterhalb der Menüleiste.

3. Drücken Sie STRG+F5, um die Anwendung auszuführen, oder wechseln Sie zum Debuggen-Menü, und wählen Sie dort Ohne Debuggen starten aus. Es sollte nun ein Konsolenfenster mit dem im Code angegebenen Text angezeigt werden.

4. Schließen Sie das Konsolenfenster, sobald Sie fertig sind.

Hinzufügen von Code für Berechnungen

Jetzt können Sie mathematische Logik hinzufügen.

Hinzufügen einer Rechnerklasse

1. Wechseln Sie zum Menü Projekt, und wählen Sie Klasse hinzufügen aus. Geben Sie im Eingabefeld für Klassenname den Namen Calculator (Taschenrechner) ein. Klicken Sie auf OK. Zwei neue Dateien werden Ihrem Projekt hinzugefügt. Um alle geänderten Dateien auf einmal zu speichern, drücken Sie STRG+UMSCHALT+S. Dies ist die Tastenkombination für Datei>Alle speichern. Es gibt auch eine Symbolleistenschaltfläche für Alle speichern: ein Symbol mit zwei Disketten. Diese Schaltfläche befindet sich neben der Schaltfläche Speichern. Generell hat es sich bewährt, Alle speichern häufig auszuführen, damit auch wirklich alle Dateien gespeichert werden.

   

   Eine Klasse ist wie ein Entwurf für ein Objekt, das etwas tut. In diesem Fall soll ein Rechner und dessen Funktionsweise definiert werden.

   Der Assistent Klasse hinzufügen, den Sie zuvor verwendet haben, hat .h- und .cpp-Dateien erstellt, die denselben Namen wie die Klasse haben. Im am Rand der IDE angezeigten Fenster Projektmappen-Explorer können Sie sich eine vollständige Liste Ihrer Projektdateien ansehen. Wenn das Fenster nicht angezeigt wird, können Sie es über die Menüleiste öffnen: Klicken Sie auf Ansicht>Projektmappen-Explorer.

   

   Sie sollten in Editor nun drei Registerkarten geöffnet haben: CalculatorTutorial.cpp, Calculator.h und Calculator.cpp. Wenn Sie eine davon versehentlich schließen, können Sie sie im Projektmappen-Explorer-Fenster jeweils mit einem Doppelklick auf die Datei wieder öffnen.

2. Ersetzen Sie den Inhalt von Calculator.h durch den folgenden Code, sodass die Datei jetzt wie folgt aussieht:

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

   Grundlegendes zum Code

   • Dieser Code deklariert eine neue Funktion namens Calculate, die Sie verwenden, um mathematische Operationen für Addition, Subtraktion, Multiplikation und Division auszuführen.
   • C++-Code ist unterteilt in Headerdateien (.h) und Quelldateien (.cpp). Von verschiedenen Compilern werden auch noch andere Dateierweiterungen unterstützt; die eben vorgestellten sind aber die wichtigsten, die Sie kennen sollten. Funktionen und Variablen werden normalerweise deklariert, d. h. ihnen wird in den Headerdateien ein Name und ein Typ zugeordnet, und implementiert, d. h. ihnen wird in den Quelldateien eine Definition zugeordnet. Um auf in einer anderen Datei definierten Code zuzugreifen, können Sie #include "filename.h" verwenden. Dabei ist filename.h der Name der Datei, die die Variablen und Funktionen deklariert, die Sie verwenden möchten.
   • Es hat sich bewährt, Ihren Code auf Grundlage der jeweiligen Funktion in verschiedenen Dateien zu organisieren. Dies erleichtert das spätere Auffinden des benötigen Codes. Hier definieren Sie die Calculator-Klasse und die Datei, die die main()-Funktion enthält, einzeln. Es soll aber dennoch in main() auf die Calculator-Klasse verwiesen werden.

3. Unter Calculate wird eine grüne Wellenlinie angezeigt, da wir die Calculate-Funktion in der .cpp-Datei nicht definiert haben. Zeigen Sie auf Calculate, klicken Sie auf den Abwärtspfeil auf dem angezeigten Schraubenzieher, und wählen Sie Definition von „Calculate“ in Calculator.cpp erstellen aus.

   

   Ein Popupelement wird angezeigt, das Ihnen eine Vorschau der Codeänderung anzeigt, die in der anderen Datei vorgenommen wurde. Der Code wurde Calculator.cpp hinzugefügt.

   

   Momentan wird nur 0.0 zurückgegeben. Ändern Sie das nun. Drücken Sie ESC, um das Popupelement zu schließen.

4. Wechseln Sie zur Calculator.cpp-Datei im Editorfenster. Entfernen Sie die Abschnitte Calculator() und ~Calculator() (wie bereits in der .h-Datei), und fügen Sie Calculate() den folgenden Code hinzu:

   #include "Calculator.h"
   
   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;
       }
   }
   

   Grundlegendes zum Code

   • Die Funktion Calculate nimmt eine Zahl, einen Operator und eine zweite Zahl, und führt dann die angeforderte Operation mit den angegebenen Zahlen durch.
   • Die Switch-Anweisung überprüft, welcher Operator bereitgestellt wurde, und führt nur den für diese Operation entsprechenden Fall aus. Der „default:“-Fall ist ein Fallback, falls der Benutzer einen Operator eingibt, der nicht akzeptiert wird, damit das Programm nicht unterbrochen wird. Allgemein wird mit ungültiger Benutzereingabe am besten auf elegantere Weise umgegangen. Dies würde für dieses Tutorial aber zu weit führen.
   • Das double-Schlüsselwort denotiert eine Zahlenart, die Dezimalzahlen unterstützt. Auf diese Weise kann der Rechner sowohl Berechnungen mit Dezimalzahlen als auch mit ganzen Zahlen verarbeiten. Die Calculate-Funktion muss aufgrund von double ganz am Anfang des Codes (dadurch wird der Rückgabetyp der Funktion angegeben) immer eine solche Zahl zurückgeben. Deshalb wird auch im „default:“-Fall 0.0 zurückgegeben.
   • Die .h-Datei deklariert die Funktion prototype, die dem Compiler bereits vorab sagt, welcher Parameter benötigt wird, und welcher Rückgabetyp zu erwarten ist. In der .cpp-Datei sind alle Implementierungsdetails der Funktion enthalten.

Wenn Sie nun den Code noch einmal erstellen und ausführen, wird er nach der Aufforderung, den gewünschten Vorgang anzugeben, erneut beendet. Bearbeiten Sie als nächsten Schritt die main-Funktion, um einige Berechnungen durchzuführen.

So rufen Sie Memberfunktionen der Calculator-Klasse auf

1. Aktualisieren Sie nun die main-Funktion in CalculatorTutorial.cpp:

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

   Grundlegendes zum Code

   • Da C++-Programme immer bei der main()-Funktion starten, müssen Sie den weiteren Code von dort aus aufrufen. Es wird also eine #include-Anweisung benötigt.
   • Einige anfängliche Variablen (x, y, oper und result) werden deklariert, um jeweils die erste Zahl, die zweite Zahl, den Operator und das Endergebnis zu speichern. Es empfiehlt sich immer, einige anfängliche Variablen anzugeben, um nicht definiertes Verhalten zu vermeiden. Genau dies ist hier geschehen.
   • Die Calculator c;-Zeile deklariert ein Objekt namens „c“ als Instanz der Calculator-Klasse. Die Klasse selbst ist lediglich ein Entwurf dafür, wie der Rechner funktioniert. Das Objekt ist der spezifische Rechner, der die Berechnungen ausführt.
   • Die while (true)-Anweisung ist eine Schleife. Der Code innerhalb der Schleife wird wieder und wieder ausgeführt, so lange, bis die Bedingung innerhalb der () erfüllt ist. Da die Bedingung nur als true aufgeführt ist, ist sie immer wahr, die Schleife wird also ununterbrochen ausgeführt. Um das Programm zu schließen, muss der Benutzer das Konsolenfenster manuell schließen. Andernfalls wartet das Programm ständig auf eine neue Eingabe.
   • Das cin-Schlüsselwort wird verwendet, um Benutzereingaben anzunehmen. Dieser Eingabestream ist intelligent genug, um eine Textzeile zu verarbeiten, die im Konsolenfenster eingegeben wird, und diese in der richtigen Reihenfolge innerhalb aller aufgeführten Variablen zu platzieren, vorausgesetzt, die Benutzereingabe entspricht den benötigten Spezifikationen. Sie können diese Zeile bearbeiten, sodass verschiedene Eingabearten akzeptiert werden, z. B. mehr als zwei Zahlen. Dafür müsste aber auch die Calculate()-Funktion aktualisiert werden.
   • Der c.Calculate(x, oper, y);-Ausdruck ruft die zuvor definierte Calculate-Funktion auf und stellt die eingegebenen Eingabewerte zur Verfügung. Die Funktion gibt dann eine Zahl zurück, die in result gespeichert wird.
   • Abschließend wird result in der Konsole ausgegeben, sodass der Benutzer das Ergebnis der Berechnung ansehen kann.

Erneutes Erstellen und Testen des Codes

Testen Sie das Programm nun erneut, ob auch alles wie vorgesehen funktioniert.

1. Drücken Sie STRG+F5, um die App neu zu erstellen und zu starten.

2. Geben Sie 5+5 ein, und drücken Sie die EINGABETASTE. Überprüfen Sie, ob das Ergebnis 10 ist.

   

Debuggen der App

Da es keine Beschränkungen gibt, was der Benutzer im Konsolenfenster eingeben kann, sorgen Sie nun dafür, dass der Rechner Eingaben wie erwartet verarbeitet. Anstatt das Programm auszuführen, debuggen Sie es, damit Sie sich ansehen können, wie genau das Programm Schritt für Schritt abläuft.

Ausführen der App im Debugger

1. Legen Sie einen Haltepunkt in der Zeile result = c.Calculate(x, oper, y); fest. Um den Breakpoint festzulegen, klicken Sie auf der linken Seite des Editorfensters neben der Zeile auf den grauen, vertikalen Rand. Ein roter Punkt wird angezeigt.

   

   Ab sofort wird die Ausführung dann immer bei dieser Zeile angehalten, wenn Sie das Programm debuggen. Wir haben bereits eine grobe Vorstellung, dass das Programm in einfachen Fällen funktioniert. Da wir die Ausführung nicht jedes Mal anhalten möchten, legen wir den Breakpoint als bedingt fest.

2. Klicken Sie mit der rechten Maustaste auf den roten Punkt, der den Breakpoint darstellt, und wählen Sie dann Bedingungen aus. Geben Sie im Eingabefeld für die Bedingung (y == 0) && (oper == '/') ein. Wählen Sie die Schaltfläche Schließen aus, wenn Sie fertig sind, um die Haltepunktbedingung zu speichern.

   

   Die Ausführung wird nun also genau dann am Breakpoint angehalten, wenn versucht wird, durch 0 zu teilen.

3. Drücken Sie F5, um das Programm zu debuggen, oder wählen Sie die Schaltfläche Lokaler Windows-Debugger mit dem grünen Pfeilsymbol auf der Symbolleiste aus. Wenn Sie in Ihrer Konsolen-App z. B. „5 - 0“ eingeben, verhält sich das Programm normal und wird weiter ausgeführt. Wenn Sie nun jedoch „10 / 0“ eingeben, hält das Programm am Breakpoint an. Auch wenn Sie eine beliebige Anzahl von Leerzeichen zwischen dem Operator und den Zahlen einfügen, ist cin intelligent genug, die Eingabe korrekt zu analysieren.

   

Nützliche Fenster im Debugger

Sobald Sie Ihren Code debuggen, können Sie feststellen, dass ein paar neue Fenster angezeigt werden. Diese Fenster unterstützen Sie beim Debuggen. Sehen Sie sich das Fenster Auto an. Im Fenster Auto sehen Sie die aktuellen Werte der Variablen, die mindestens in den letzten drei Zeilen und bis zur aktuellen Zeile verwendet wurden. Wenn Sie alle Variablen dieser Funktion ansehen möchten, wechseln Sie zum Fenster Lokale. Sie können die Werte dieser Variablen während des Debuggens bearbeiten, um zu erfahren, welche Auswirkung sie auf das Programm haben würden. Hier bearbeiten Sie die Variablen jedoch nicht.

Sie können auch einfach direkt im Code den Mauszeiger auf Variablen bewegen, um deren aktuelle Werte an den Stellen anzeigen zu lassen, an denen die Ausführung jeweils pausiert wurde. Sorgen Sie dafür, dass sich das Editorfenster im Vordergrund befindet, indem Sie darauf klicken, bevor Sie diesen Vorgang testen.

Fortsetzen mit dem Debuggen

1. Der gelbe Pfeil auf der linken Seite zeigt den aktuellen Punkt der Ausführung. Die aktuelle Zeile ruft Calculate auf. Drücken Sie also F11, um einen Einzelschritt in der Funktion auszuführen. Jetzt führen Sie Code im Textkörper der Calculate-Funktion aus. Wenden Sie Einzelschritt mit Vorsicht an, da sie damit in alle Funktionen in der Zeile gelangen, in der Sie sich befinden, einschließlich Standardbibliotheksfunktionen. Es ist in Ordnung, in die Standardbibliothek zu gehen, aber Sie möchten sich wohl eher auf Ihren eigenen Code statt auf den Bibliothekscode konzentrieren.

2. Der Ausführungsstand befindet sich nun gerade auf dem Beginn der Calculate-Funktion. Drücken Sie F10, um zur nächsten Zeile in der Programmausführung zu wechseln. F10 wird auch als Prozedurschritt bezeichnet. Sie können die Option Überspringen verwenden, um von Zeile zu Zeile zu springen, ohne dabei genau die Details jedes Teils der Zeile anzusehen. Prinzipiell sollten Sie Überspringen gegenüber Hineinspringen bevorzugen, es sei denn, Sie möchten sich wirklich den Code genauer ansehen, der von einem anderen Punkt abgerufen wird, so wie Sie dies getan haben, um sich den Textkörper von Calculate anzusehen.

3. Verwenden Sie F10, um solange Zeilen zu überspringen, bis Sie sich wieder in der main()-Funktion in der anderen Datei befinden, und halten Sie dort in der Zeile cout an.

   Es scheint, das Programm funktioniert wie erwartet: Es nimmt die erste Zahl und dividiert sie durch die zweite. Bewegen Sie in der cout-Zeile den Mauszeiger über die Variable result, oder sehen Sie sich result im Fenster Auto an. Sein Wert ist inf, was offenbar falsch ist, also korrigieren wir dies. Die cout-Zeile gibt nur aus, welcher Wert auch immer in result gespeichert ist. Wenn Sie also mithilfe von F10 eine Zeile weiter springen, wird im Konsolenfenster Folgendes angezeigt:

   

   Dieses Ergebnis resultiert daraus, dass die Division durch Null (0) nicht definiert ist. Das Programm hat also keine numerische Antwort für die angeforderte Operation.

Beheben des Fehlers „Division durch Null“

Wir sollten die Division durch null eleganter handhaben, damit die Benutzer*innen das Problem besser verstehen.

1. Nehmen Sie in CalculatorTutorial.cpp die folgenden Änderungen vor. (Dank eines Debuggerfeatures namens Bearbeiten und Fortfahren kann das Programm weiter ausgeführt werden, während Sie Änderungen vornehmen). Die Änderung besteht darin, eine if-Anweisung nach cin >> x >> oper >> y; hinzuzufügen, um zu überprüfen, ob eine Division durch 0 stattgefunden hat, und eine Nachricht an die Benutzer*innen auszugeben, falls dies geschieht. Andernfalls wird das Ergebnis ausgegeben.

   // 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. Drücken Sie nun einmal F5. Die Programmausführung wird ordnungsgemäß fortgeführt, bis das Programm pausiert, um eine Benutzereingabe anzufordern. Geben Sie noch einmal 10 / 0 ein. Nun wird eine hilfreichere Antwort ausgegeben. Der Benutzer wird zu weiterer Eingabe aufgefordert, und das Programm wird weiter normal ausgeführt.

   

   Im Konsolenfenster werden zwei Zeilen angezeigt: 10 / 0 mit dem Ergebnis „inf“, gefolgt von 10 / 0 mit der Ausnahme für die Division durch 0.

   Hinweis

   Wenn Sie Code bearbeiten, während sich das Programm im Debugmodus befindet, besteht die Gefahr, dass der Code veraltet. Dies geschieht, wenn der Debugger noch Ihren alten Code ausführt, und Ihre Änderungen noch nicht übernommen wurden. In so einem Fall werden Sie durch ein Dialogfeld vom Debugger informiert. Gelegentlich sollten Sie F5 drücken, um den gerade ausgeführten Code zu aktualisieren. Insbesondere wenn Sie eine Änderung in einer Funktion vornehmen, während sich der Ausführungspunkt genau innerhalb dieser Funktion befindet, müssen Sie einen Schritt aus dieser Funktion vornehmen, und danach wieder in die Funktion springen, um den aktualisierten Code zu erhalten. Wenn dies aus welchen Gründen auch immer nicht funktioniert, und eine Fehlermeldung zurückgegeben wird, können Sie das Debuggen anhalten, indem Sie oben in der IDE in der Symbolleiste unter den Menüs auf das rote Quadrat klicken, dann das Debugging mithilfe von F5 erneut starten, oder in der Symbolleiste neben der Stoppschaltfläche auf den grünen Wiedergabepfeil klicken.

   Bei „Bearbeiten und Fortfahren“ kann auch eine Fehlermeldung angezeigt werden, dass die Einstellung „Quelldateien müssen exakt mit der Originalversion übereinstimmen“ unter „Debuggen->Optionen->Allgemein“ aktiviert werden muss. Wählen Sie in diesem Fall im Hauptmenü Extras>Optionen>Debuggen>Allgemein aus, und stellen Sie sicher, dass Quelldateien müssen exakt mit der Originalversion übereinstimmen aktiviert ist.

   Grundlegendes zu den Tastenkombinationen zum Ausführen und Debuggen

   • F5 bzw. Debuggen>Debuggen starten startet eine Debugsitzung, wenn noch keine aktiv ist, und führt das Programm so lange aus, bis ein Breakpoint erreicht wird, oder das Programm Benutzereingabe erfordert. Wenn keine Benutzereingabe benötigt wird, und es keinen Breakpoint gibt, der erreicht werden könnte, wird das Programm beendet, und das Konsolenfenster schließt sich automatisch, sobald das Programm die Ausführung beendet hat. Wenn Sie ein „Hallo Welt“- oder ähnliches Programm ausführen, verwenden Sie STRG+F5, oder legen einen Haltepunkt fest, bevor Sie F5 drücken, damit das Fenster nicht geschlossen wird.
   • Mit STRG+F5 bzw. Debuggen>Ohne Debuggen starten wird die Anwendung ausgeführt, ohne dass der Debugmodus gestartet wird. Dies benötigt etwas weniger Zeit als das Debuggen, und das Konsolenfenster bleibt geöffnet, nachdem das Programm die Ausführung beendet hat.
   • F10 bzw. Überspringen ermöglicht es Ihnen, Zeile für Zeile den Code zu durchlaufen, wodurch Sie eine Vorstellung davon erhalten, wie der Code ausgeführt wird, und welche Variablenwerte es an jedem Ausführungsschritt gibt.
   • F11 bzw. Hineinspringen funktioniert ähnlich wie Überspringen. Allerdings wird hierbei in jede Funktion hineingesprungen, die auf der jeweiligen Ausführungszeile aufgerufen wird. Wenn die Zeile, die ausgeführt wird, z. B. eine Funktion aufruft, lässt F11 den Zeiger in den Textkörper dieser Funktion springen, damit Sie dem ausgeführten Funktionscode folgen können, bevor Sie zur Zeile zurückkehren, in der Sie F11 gedrückt haben. Wenn Sie F10 drücken, werden Funktionsaufrufe einfach übersprungen, und der Zeiger geht einfach zur nächsten Zeile. Der Funktionsaufruf findet dennoch statt, das Programm pausiert jedoch nicht, damit Sie sich ansehen können, was es gerade tut.

Schließen der App

• Wenn die Ausführung noch nicht beendet ist, schließen Sie das Konsolenfenster für die Rechner-App.

Hinzufügen einer Git-Quellcodeverwaltung

Nachdem Sie eine App erstellt haben, können Sie sie einem Git-Repository hinzufügen. Wir haben für Sie gesorgt. Visual Studio vereinfacht diesen Prozess mit Git-Tools, die Sie direkt über die IDE verwenden können.

Tipp

Git ist das am häufigsten verwendete moderne Versionskontrollsystem. Unabhängig davon, ob Sie professioneller Entwickler sind oder erst die Grundlagen des Programmierens erlernen, kann Git sehr nützlich für Sie sein. Wenn Sie noch nicht mit Git vertraut sind, ist die Website https://git-scm.com/ ein guter Ausgangspunkt. Dort finden Sie Kurzübersichten, ein beliebtes E-Book sowie Videos zu den Git-Grundlagen.

Um Ihren Code Git zu zuordnen, müssen Sie zunächst ein neues Git-Repository erstellen, in dem sich Ihr Code befindet. Gehen Sie dazu wie folgt vor:

1. Wählen Sie in der Statusleiste in der rechten unteren Ecke von Visual Studio die Schaltfläche Zur Quellcodeverwaltung hinzufügen und dann Git aus.

   

2. Melden Sie sich in dem Dialogfeld Ein Git-Repository erstellen in GitHub an.

   

   Der Repositoryname wird für Ihren Ordnerspeicherort automatisch aufgefüllt. Ihr neues Repository ist standardmäßig privat. Das bedeutet, dass Sie die einzige Person sind, die darauf zugreifen kann.

   Tipp

   Unabhängig davon, ob Ihr Repository privat oder öffentlich ist, sollten Sie über eine auf GitHub gespeicherte Remotesicherung Ihres Codes verfügen. Auch wenn Sie nicht mit einem Team zusammenarbeiten, stellt Ihnen ein Remoterepository Ihren Code auf jedem Computer zur Verfügung.

3. Wählen Sie Erstellen und Pushen aus.

   Nachdem Sie Ihr Repository erstellt haben, werden auf der Statusleiste Details zum Status angezeigt.

   

   Das erste Symbol mit den Pfeilen zeigt, wie viele ausgehende und eingehende Commits in Ihrer aktuellen Verzweigung liegen. Sie können dieses Symbol verwenden, um die eingehenden Commits zu pullen oder ausgehende Commits mithilfe von Push zu übertragen. Sie können sich diese Commits auch zuerst anzeigen lassen. Klicken Sie dazu auf das Symbol, und wählen Sie dann Ausgehend/Eingehend anzeigen aus.

   Das zweite Symbol mit dem Stift zeigt Ihnen die Anzahl der Änderungen ohne Commits an Ihrem Code an. Sie können auf dieses Symbol klicken, um diese Änderungen im Fenster Git-Änderungen anzuzeigen.

Weitere Informationen zur Verwendung von Git mit Ihrer Anwendung finden Sie in der Dokumentation zur Visual Studio-Versionskontrolle.

Die fertige App

Herzlichen Glückwunsch! Sie haben den Code für die Taschenrechneranwendung in Visual Studio fertiggestellt, erstellt und debuggt sowie zu einem Repository hinzugefügt.

Nächste Schritte

Weitere Informationen zu Visual Studio für C++