Eine Leinwand für den Künstler

Die Entscheidung ist gefallen! Du wirst programmieren lernen. Die Euphorie ist groß, es kribbelt dir förmlich in den Fingern und du kannst es kaum erwarten, deinen Computer in schwindelerregender Geschwindigkeit mit Codezeilen zu bewerfen.

Doch halt! So wie ein Maler eine Leinwand und ein Schriftsteller ein Blatt Papier braucht, braucht auch der Programmierer ein Medium, in dem er seine informatischen Eingebungen verwirklichen kann. Und das ermöglichen dir so genannte Entwicklungsumgebungen. Von denen gibt es einige. Auf schnellstem und unkompliziertestem Wege kannst du auf der Seite cpp.sh gleich mit dem Programmieren anfangen. Cpp.sh ist ein Online-Compiler, mit dem du kleine C++-Programme schreiben kannst. Für kurze Programme ideal geeignet – doch bei größeren Projekten empfiehlt es sich, auf die Entwicklungsumgebung Visual Studio von Microsoft umzusteigen. Visual Studio kann kostenlos aus dem Netz heruntergeladen werden. Da man bei den vielen Funktionen des Programms schnell den Überblick verlieren kann, geben wir dir hier eine kleine Anleitung, wie du eine Datei zum Programmieren öffnen kannst:

1. Klicke auf Datei->Neu und anschließend auf „Projekt“.
2. In dem nun geöffneten Fenster wählst du links unter dem Register „Visual C++“ den Punkt „Windows Desktop“ aus. Es erscheinen nun eine Reihe von Projekttypen. Wähle „Windows-Desktopassistent“.
3. Als einzigen Parameter wählst du „Leeres Projekt“ aus. Entferne die Häckchen bei allen anderen Optionen.
4. Wähle rechts unter „Quelldatei“ auf „Hinzufügen“ und im Anschluss auf „Neues Element“.
5. Füge dem Projekt eine C++-Datei hinzu.
6. Fertig! Von nun an kannst du kleine Programme schreiben. Möchtest du deinen Code testen, klicke auf Erstellen->Projektmappe erstellen. Der Compiler prüft dein Programm auf Fehler. Ist dein Code fehlerfrei, kannst du unter Debuggen->Starten ohne Debugging dein Programm zum Laufen bringen.

Sollte dir Visual Studio nicht liegen, kannst du auch gerne nach anderen Entwicklungsumgebungen stöbern. Vielleicht sagt dir ja Code::Blocks mehr zu? Probiere dich ruhig vorher aus! Doch egal, für welche Entwicklungsumgebung du dich entscheidest: Schlussendlich geht’s um das Programmieren. Und damit wollen wir nun endlich beginnen. 

Der ständig fragende Computer

Was ist eine Banane? Ist doch logisch: Eine Frucht - wirst du dir denken. Viel mehr stellt sich dir jetzt bestimmt die Frage: Was ist das für eine komische Einleitung für einen Lehrtext über das Programmieren?

Eine ziemlich gute, wie du hoffentlich merken wirst. Denn ein Computer fragt sich das ständig.

Na ja, so fast. Ein Computer kennt natürlich keine Bananen. Dafür aber: Zahlen. Mit Zahlen kann er etwas anfangen. Denn wenn es um das Programmieren geht, stehen natürlich Zahlen und das Rechnen mit ihnen im Vordergrund. Das erwarten wir schließlich von einer Maschine, die man „Computer“ (dt. Rechner) genannt hat.

Dennoch: Wirfst du deinem Computer eine „1“ an den Kopf, wird er sich eben fragen:

Was ist „1“?

Und er hat noch mehr Fragen: Was ist „3“? Was ist „7.12“? Und ist „7.12“ von derselben Art wie „3“?

Klar, wir würden sagen, es sind alles Zahlen. Und genau dies ist dem Computer wichtig: Zu wissen, dass es gerade eben Zahlen sind – und keine Früchte oder sonst etwas. Genauso wie wir in der Realwelt verschiedenartige Typen von Objekten unterscheiden, tut dies auch der Computer. Da der Computer aber meist nichts anderes als Zahlen kennt, muss er irgendwie Ordnung in diese riesige Menge bringen. Zahl ist nämlich nicht gleich Zahl. So gibt es zum einen ganzzahlige Werte wie 1, 2 und 5000, im Computer-Jargon „Integer“-Werte genannt, auf der anderen Seite haben wir Fließkommazahlen, so genannte „Float“- und „Double“-Werte. Halten wir fest: Der Computer unterschiedet also zwischen verschiedenen Zahlen, oder besser: zwischen Datentypen.

Dass der Computer nämlich nur Zahlen kennt, war ein bisschen gelogen. Besser ist der Begriff der „Daten“. Neben Ganzzahlen und Fließkommazahlen sind dem Computer immerhin auch Zeichen („Character“) und Wahrheitswerte („Boolean“-Werte) ein Begriff. 

Alles, was der Computer also an Informationen verarbeitet, hat und muss einen bestimmten Typ haben. Sonst fragt dich der Computer ständig: Was ist das? Was wirfst du mir da an die Prozessordecke? 

Will man nun mit bestimmten Elementen dieser Datentypen arbeiten, muss man dies dem Computer bekanntgeben. Hier kommt der Begriff der „Variable“ ins Spiel. Dies ist ein Name für einen bestimmten Wert, oder genauer: Ein Behälter für einen Wert. In einem Programm könnte dies so aussehen:

    int main(){

        int i;

        float f;

        double d;

        char c;

        bool b;
        ...

    }

An diesem kurzen Programmschnipsel werden unsere vorherigen Ausführungen nochmal deutlich: Der Computer arbeitet mit Datentypen. Hättest du dem Computer einfach so ein „i“ oder ein „f“ überreicht und damit munter angefangen zu rechnen, hätte dich der Computer schief angesehen und gefragt: Was ist „i“? Was ist „f“? Im Gespräch mit dem Computer muss du strukturiert und logisch vorgehen und ihm sagen: Ich führe die Variable „Banane“ ein. Eine Banane ist vom Typ her eine Frucht. 

Das, was hier mit „i“, „f“, „d“, „c“ und „b“ bezeichnet wurde, sind nun unsere Variablen. Hast du dem Computer einmal erklärt, was eine Banane ist, weiß er es und kann von nun an damit etwas anfangen. Variablen sind erst nach ihrer Bekanntgabe, der so genannten Deklaration, nutzbar. Diesen Variablen können nun konkrete Werte zugeordnet werden. Unserer Variablen „i“ kann nun beispielsweise jeder beliebe Integer-Wert, also eine Ganzzahl, zugeschrieben werden. „c“ hingegen kann ein Zeichen zugewiesen werden. Im Programm kann dies so aussehen

    int main() {

        int i = 1;

        float f = 7.12;

        char c= 'A';

        bool b = true;
        ...

    }

Beachte dabei, dass bei der Wertzuweisung von Charactern die Hochkommata verwendet werden ('). Dadurch werden die character-Werte von anderen Variablennamen unterschieden. 

Auch möglich wäre, Deklaration und Zuweisung zu trennen:

    int main() {

        int i;

        i = 1;
        ...

    }

Variablen stehen stellvertretend für den Wert, den man ihr zuweist. Will man beispielsweise mit der Zahl Pi rechnen, führt man sie zunächst einmal ein, wie hier geschehen:

    double pi = 3.14159;

und kann anschließend beliebige Operationen mit Pi durchführen, ohne ständig die Ziffern nochmal einzutippen. Das ist insofern von Vorteil, weil du damit der Gefahr von Tippfehlern vorbeugst.

Stelle dir Variablen wie bunte Klebezettel vor. Die verschiedenen Farben stehen jeweils für die unterschiedlichen Datentypen, die sie annehmen können. Jedes Mal, wenn du eine Variable deklarierst, klebst du den Zettel auf eine riesige Tafel, die hier symbolisch für den Speicher des Computers steht. In dem Moment, wo du auf den Klebezettel etwas draufschreibst, sei es „1“ oder „A“, weist du der Variable (=Klebezettel) einen Wert zu. Auf die grellgelben Zettel können aber nur Ganzzahlen und auf die neonpinken nur Zeichen geschrieben werden – das ist das Prinzip von Datentypen, Variablen und Werten. 

Gehen wir jetzt mal näher auf die Tafel ein, auf der sich all unsere bunten Klebezettel befinden. Irgendwo müssen die Variablen schließlich gelagert werden, denn immerhin haben wir gesagt: Einmal deklariert, also einmal erklärt, was eine Banane ist, und der Computer weiß es und kann auf diese Information immer wieder zugreifen. Diese Tafel, diese Lagerhalle der Variablen, ist der Speicher, das „Gedächtnis“ deines Computers. Das Bild der Lagerhalle trifft es eigentlich ganz gut: Genauso wie man in einem riesigen Lagerbestand wissen sollte, in welchem der vielen Regale nun die gesuchten Gegenstände herumliegen, hat auch der Speicher eine Ordnung. Variablen wird nämlich eine Adresse im Speicher zugewiesen, sie erhalten eine feste Position, die im Speicher eine etwas kryptische Bezeichnung wie "0010101001011010“ tragen kann. Doch diese Adressen sollen uns zunächst nicht weiter interessieren. Wichtig ist: Es gibt diese bestimmten Speicher-Adressen und -Orte für jede Variable. 

Nun müssen wir gestehen: Wir haben erneut gelogen. Denn das einzige, was der Computer wirklich weiß, ist 0 und 1. Man mag es kaum glauben, aber das reicht schon aus, um eine Menge grandioser Sachen damit anzustellen. Nur mithilfe von 0 und 1 können nämlich Werte für eine Variable, wie 482 für einen Integer oder A für einen Character, gespeichert werden. Betrachten wir dazu folgende Darstellung:

Eine Stelle im Speicher (also eine 0 oder 1) wird als Bit bezeichnet. 8 dieser Bits ergeben ein Byte. Nun haben Datentypen wie Integer, Float und Double verschieden große Speicherbereiche. Während Character-Werte mit mickrigen 8 Bit (=8 Kästchen=1 Byte) auskommen müssen, haben Integer-Werte schon 32 Bit (=32 Kästchen=4 Byte) Speicherplatz. Diese Speichergröße legt fest, welche Zahlen überhaupt dargestellt werden können. Bei 32 Bit Speicherplatz kann in jedem der 32 Kästchen höchstens die Binärzahl 11111111111111111111111111111111 stehen, was in der uns bekannten Dezimalschreibweise der Zahl 4294967295 entspricht. Mit anderen Worten: Hat ein Integer 32 Bit Speicherplatz, kann die Zahl 4294967296 sowie alle größeren Zahlen als diese in keiner int-Variable mehr gespeichert werden. 
Wenn du dieses Prinzip nochmal für Character durchgehst, wirst du dich sicherlich fragen: Wie kann aus einer Zahl, die höchstens den Wert 11111111 (=255) annimmt, auf ein Zeichen geschlossen werden? Die Lösung ist: Die ASCII-Tabelle, in der eine bestimmte Zahl jeweils für ein Zeichen steht.

In dieser Tabelle befindet sich ein Überblick über die verschiedenen Datentypen, ihre Speichergrößen und ihre Wertebereiche:

Bei der aufmerksamen Lektüre der Tabelle fällt auf, dass wir wohl ein paar Datentypen verschwiegen haben: Was hat es mit Begrifflichkeiten wie „short“, „long“, „signed“ und „unsigned“ auf sich?
Tatsächlich stellen diese Schlüsselwörter Modifikatoren da, mit denen die uns bekannten Datentypen leicht angepasst werden können. Vielleicht kam dir ja die Frage auf, ob man einer int-Variable nicht auch die Zahl „-3“ zuweisen kann. Ja – aber auch dies musst du dem Computer weiß machen, indem du den Datentyp „signed int“ nennst. Mit „signed“ legst du fest, dass auch negative Werte erlaubt sind. „unsigned“ bewirkt das Gegenteil. Mit „long“ und „short“ kannst du den Wertebereich eines Datentyps entsprechend lang oder kurz halten. „short“ und „long“ können jedoch auch selbst als Datentypen fungieren. Wie viel Bit für jeden Datentyp bereitgestellt werden, ist abhängig vom jeweilige Prozessor, es gibt jedoch dafür einige Festlegungen:

short int <= int <= long int
float <= double <= long double

Nun bist du mit ausreichend Wissen über Datentypen und Variablen ausgestattet. Das ist jedoch noch kein Grund, sich zurückzulehnen – denn Variablen zu deklarieren ist eine Sache – aber mit ihnen zu arbeiten, also Operationen damit durchzuführen, ist der wahre Kern des Programmierens.
Gönne dir also eine kleine Pause, bevor es weiter geht – schnappe dir ruhig eine Banane zur Stärkung. Jetzt weißt du ja, was eine Banane ist. Und dann gibt's ein paar kleine Programmieraufgaben dazu. 

Ein Gespräch mit dem Computer

Wer anfängt, mit seinem Computer zu reden, wird für gewöhnlich für verrückt erklärt. Nicht bei uns! Denn das Geplänkel mit dem Computer gehört zum Handwerkszeug des angehenden Programmierers. Und mit Geplänkel meinen wir konkret: Ein- und Ausgaben von Daten implementieren zu können. Mit dem Wissen über Ein- und Ausgabe wirst du beispielsweise in der Lage sein, kleine Menüs für dein Programm erstellen zu können. 

Genug der Vorrede! Um das Sprechen mit dem Computer überhaupt erst möglich zu machen, musst du zu Anfang deines Programms immer den Befehl

    #include <iostream> 

eingeben. Das mag zunächst eine etwas kryptische Schreibweise sein, doch lass dich davon nicht beirren. „iostream“ steht für nichts anderes als „Input-Output-Stream“ und meint eine Bibliothek, in der bestimmte Operationen und Befehle gespeichert sind. Ohne das Einbinden dieser Bibliothek wäre es gar nicht möglich, Ein- und Ausgaben zu erzeugen. So kommt diese Bibliothek mit den für uns nun wichtigen Befehlen „cout“ und „cin“ einher. 

Die Anweisung „cout“ ermöglicht es, Daten und Informationen auf dem Bildschirm ausgeben zu lassen:

    cout << "Ich bin ein Computer!";

    cout << "Willkommen in meinem ersten Programm!“;

So einfach kann man seinem Computer das Sprechen beibringen! Merke, dass Texte stets mit Anführungszeichen (" ") angegeben werden müssen.

Neben Texten kannst du jedoch auch Werte von Variablen ausgeben lassen:

    int zahl=1;

    cout << zahl;

Auf dem Bildschirm ploppt nun eine „1“ auf. Hinter dem „<<“-Operator kann jedoch auch ein Ausdruck stehen:

    int radius=1;

    int pi=3.14159;

    cout << radius*radius*pi;

Möchtest du mehrere Daten ausgeben, musst du vor jeder Informationseinheit den „<<“-Operator angeben:

    cout << "Flaecheninhalt:“ << radius*radius*pi;

Die Textformatierung ist in C++ ebenso möglich. Zwar kannst du nicht unbedingt die Schriftart deiner Ausgabe verändern, dafür aber Einfluss auf die Position der Ausgabe haben. Die Bibliothek <iomanip> hält eine Reihe von nützlichen Befehlen bereit:

-setw(n): setzt die Breite für die Ausgabe fest. Hat die anschließend folgende Ausgabe weniger Stellen, so wird die Ausgabe von links mit Leerzeichen aufgefüllt. 

-setfill(c): In Kombination mit setw werden die Leerzeichen durch das angegebene Symbol c ersetzt. 

-left: Ermöglicht die linksbündige Ausgabe innerhelb der definierten Breite.

Noch häufiger wird jedoch der Befehl "endl" gebraucht, mit dem du einen Zeilenumbruch setzen kannst. Dieser ist aber schon in der <iostream>-Bibliothek enthalten und muss nicht zusätzlich geladen werden.

Ein kurzes Programm soll verdeutlichen, wie diese Manipulatoren funktionieren:

    #include <iomanip>

    #include <iostream>

    using namespace std;

    int main() {

        int zahl=8;

        cout << zahl << endl;

        cout << setw(10) << zahl << endl;

        cout << setw(10) << setfill('*') << zahl << endl;

        cout << setw(10) << setfill('*') << left << zahl << endl;

    }

Als Ausgabe dieses kleinen Programms erhältst du:

Schön und gut, wenn dich der Computer nun vollplappern kann. Wie nimmt man nun aber selbst an einem Gespräch mit seiner liebsten Rechenmaschine teil? Anders gefragt: Wie gelingt es mir, sogenannte Eingaben in meinem Programm zu tätigen?

Häufig will man seine Programme nämlich variabel gestalten. Ohne die Möglichkeit zur eigenen Eingabe von Werten wäre beispielsweise kein Taschenrechner funktionsfähig. Das gilt genauso für ein kleines Programm zur Flächeninhaltsberechnung eines Kreises. Es wäre doch Quatsch, das Programm so zu schreiben, dass man für jeden erdenklichen Radius eine Berechnung und Ausgabe tätigt. Wir wollen unsere Variablen vom Nutzer bestimmen lassen und dies geht mit dem Befehl „cin“. Was die Syntax angeht, funktioniert „cin“ fast genauso wie sein Pendant, „cout“:

    int zahl;

    cin >> zahl;

Statt dem „<<“-Operator verwendet man hier nun aber den „>>“-Operator. 

Gebt ihr nun diesen kleinen Programm-Code ein und lässt das Programm starten, werdet ihr aufgefordert, einen bestimmten Integer-Wert einzugeben. Dieser wird dann in der Variablen „zahl“ gespeichert. Nun könnt ihr mit der Variablen Berechnungen anstellen und das Ergebnis anschließend ausgeben. Auf diese Weise erhaltet ihr ein Programm, das Ein- und Ausgabe kombiniert:

    cout << "Kleines Programm“ << endl;

    cout << "Bitte geben Sie eine Zahl ein.“ << endl;

    int zahl;

    cin >> zahl;

    cout << "Der Nachfolger der Zahl ist:“ << zahl+1 << endl;

Schwieriger gestaltet sich die Eingabe von Texten, also alles, was länger als ein Zeichen ist. Dafür werden Kenntnisse über Strings benötigt, die ihr in dem entsprechenden Kapitel nachschlagen könnt. 

Nun habt ihr den Basiskurs Computerkommunikation abgeschlossen und könnt mit diesen Kenntnissen euren Computer plaudern lassen, was das Zeug hält.