Bergmann's Weblog – Todenbüttel

• wie Sie ein neues Projekt in Qt Creator anlegen
• wie Sie Quelltext eingeben
• wie Sie Ihr Programm compilieren, also in eine ausführbare Datei übersetzen lassen
• welcher grundlegender Aufbau einem C++-Programm inne wohnt
• wie die Teile zusammenarbeiten
• was eine Funktion ist und was sie bewirkt
• wie man mit dem Objekt cout Zeichen am Bildschirm ausgibt

Hallo Welt

1. Starten Sie Qt Creator und klicken Sie auf die Karteikarte “Entwicklung” oben in der Arbeitsfläche.
2. Klicken Sie anschließend auf die Schaltfläche “Projekt erstellen”.
3. Im Dialog “Neues Projekt” wählen Sie bitte den Eintrag “Qt-C++-Projekt -> Qt Konsolenanwendung”. Klicken Sie auf “Auswählen”.
4. Im Assistenten “Qt Konsolenanwendung” legen Sie in den entsprechenden Feldern den Namen des Programmes (hier: 001_hallo_welt) und den Speicherort fest. Klicken Sie auf “Weiter”.
5. Im nächsten Schritt legen Sie das Ziel für die Anwendung (hier: Desktop -> Qt x.x.x for Desktop) fest und klicken auf “Weiter”.
6. Im folgenden und letzten Schritt (Zusammenfassung) klicken Sie auf “Abschließen”.

Der Editor

• 001_hallo_welt.pro – Die Projektbeschreibungsdatei, sie enthält u. a. Anweisungen für den Präprozessor
• Quelldateien->main.cpp – der eigentliche Quellcode

Der Quellcode – main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <QtCore/QCoreApplication>
#include <iostream>                  
 
using namespace std;                        
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    cout << "Hallo Welt" << endl;   
 
    return a.exec();
}

Die Anatomie eines C++-Programmes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/*
* Datei: main.cpp
* Programm: 001_hallo_welt
* Autor: Michael Bergmann
*/
 
#include <QtCore/QCoreApplication>   // eine Qt Headerdatei einbinden
#include <iostream>                  // die Standard-IO-Bibliothek einbinden
 
using namespace std;                // Namensbereich für IO festlegen        
 
int main(int argc, char *argv[])    // Haupt-Einsprungsfunktion
{
    QCoreApplication a(argc, argv);
 
    cout << "Hallo Welt" << endl;   // Text ausgeben
 
    return a.exec();                // Rückgabewert setzen
}

1. Die Zeilen 1 bis 5 enthalten einen mehrzeiligen Kommentar. Kommentare dienen dazu, den Quelltext zu dokumentieren – machen Sie regen Gebrauch davon!
   Es gibt in C++ zwei Arten von Kommentaren: Mehr- und Einzeilige. Mehrzeilige Kommentare werden mit der Zeichenfolge “/*” eingeleitet und mit “*/” abgeschlossen.
   Alles, was zwischen diesen Zeichenfolgen steht, wird vom Compiler als Kommentar betrachtet und nicht übersetzt. Eine Verschachtelung von mehrzeiligen Kommentaren ist nicht erlaubt!
   Einzeilige Kommentare werden durch die Zeichenfolge “//” eingeleitet und müssen nicht abgeschlossen werden. Sie gelten ausschließlich für eine Zeile. Der Compiler betrachtet alles, was
   nach dieser Zeichenfolge kommt, für eine Zeile lang als Kommentar.
2. Die Zeilen 6, 9 und 11 sind Leerzeilen. Leerzeilen erhöhen die Lesbarkeit des Quelltextes. Sie sind nicht unbedingt nötig, jedoch praktisch.
3. Die Zeilen 7 und 8 enthalten sogenante include-Anweisungen für den Präprozessor. Damit bindet man zusätzlich erforderliche, vordefinierte Dateien ein, die dann durch den Compiler mit dem übrigen Quelltext zusammen übersetzt werden. Im vorliegenden Fall sind das in Zeile 7 die Definitionsdatei für Qt4, um überhaupt erst eine Anwendung erstellen zu können, und in Zeile 8 die Standard-Ein/Ausgabebibliothek. Sie wird benötigt, um Text mit dem Befehl (genauer: dem Objekt) “cout” an der Konsole auszugeben.

   Man bindet zusätzliche Definitionsdateien ein, indem man die Anweisung “#include”, gefolgt von der einzubindenden Datei, in den Quelltext schreibt. Hierbei verwendet man Spitze Klammern um die einzubindende Datei herum, wenn diese im Suchpfad des Compilers bekannt ist. Wenn man eigene Definitionsdateien einbinden möchte, dann setzt man diese unter Nennung des vollen Pfades in Anführungszeichen. Die Anweisung “#include” sollte für alle einzubindenden Dateien aus Gründen der Übersichtlichkeit immer am Anfang des Quelltextes stehen.

4. In Zeile 10 wir der Befehl “using”, gefolgt vom Schlüsselwort “namespace” verwendet, um den Namensbereich “std” für die Ein-/Ausgabe festzulegen (Näheres zu den verschiedenen Namensbereichen erfahren Sie später!). Das ist an dieser Stelle erforderlich, damit die Textausgabe an der Konsole erfolgen kann.

   Ein Befehl, anders als eine Anweisung, muss immer mit einem Semikolon (“;”) abgeschlossen werden. Das Vergessen dieser Regel ist eine der häufigsten Fehlerquellen in einem C++-Programm!

5. In Zeile 12 beginnt der eigentliche Hauptteil unseres Programmes: die Funktion “main“! Innerhalb dieser Funktion stehen alle Anweisungen und Befehle, die ein Programm mit Leben füllen.
   Dabei werden die einzelnen Befehle chronologisch von oben nach unten abgearbeitet. Jedes C++-Programm enthält eine Funktion main.

   Der allgemeine Aufbau einer Funktion sieht so aus: Datentyp des Rückgabewertes Name der Funktion (Datentyp des Parameters Parameter …) { Befehle… }
   Man unterscheidet den Funktionskopf mit den Parametern (hier: Zeile 12) und den Funktionsrumpf mit den zwischen öffnenden (hier: Zeile 13) und schließenden (hier: Zeile 19) spitzen Klammern notierten Befehlen, Funktionsaufrufen usw. Eine Funktion kann im Funktionskopf einen oder mehrere Parameter enthalten.

   Im Allgemeinen ist eine Funktion ein Codeblock, der eine oder mehrere Aktionen ausführt. Funktionen werden von anderen Funktionen aufgerufen.
   Die Funktion main ist bezüglich ihres Aufrufes ein Sonderfall: Sie wird beim Start des Programmes automatisch aufgerufen.

   Näheres zur Verwendung von Datentypen und Funktionsaufrufen erfahren Sie später.

Der Programmablauf

• In Zeile 14 wird die Anwendung initialisiert. Der Aufruf der Klasse QtCoreApplication bereitet die Anwendung darauf vor, eine Konsole zu öffnen.
• In Zeile 16 wird das Objekt cout dazu verwendet, einen Text an der Konsole auszugeben. Dabei weist der Umleitungsoperator “<<” die Zeichenkette “Hallo Welt” an, über cout an der Konsole zu erscheinen. “endl” ist ein Macro für die Zeichenfolge “\n” und bewirkt einen Zeilenvorschub.
• In Zeile 18 wird der Rückgabewert der Funktion gesetzt. In diesem Fall gibt die Funktion main den Status des Programmes an das Betriebssystem zurück.

Eine kurze Einführung in cout

Wie bereits erwähnt dient cout dazu, Daten auf dem Bildschirm auszugeben. Genaugenommen ist cout ein sogenannter Stream, ein Objekt, dass Daten “strömt” – in diesem Falle eben an die Konsole. Um einen Wert auf dem Bildschirm auszugeben, müssen Sie cout eingeben, gefolgt vom Umleitungsoperator (<<), den man durch zweimaliges Drücken der [<]-Taste erzeugt. Im Anschluss an den Umleitungsoperator geben Sie Ihre auszugebenden Daten an.

Listing 002_cout_ausgabe soll Ihnen die Anwendung demonstrieren. Bitte erstellen Sie ein neues Projekt im Qt Creator und ergänzen Sie den automatisch generierten Quellcode in der Datei main.cpp wie folgt um den Inhalt der Zeilen 8, 10 und 16 bis 29:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/*
* Datei: main.cpp
* Programm: 002_cout_ausgabe
* Autor: Michael Bergmann
*/
 
#include <QtCore/QCoreApplication>
#include <iostream>                  // benötigt für die Textausgabe an der Konsole
 
using namespace std;                // benötigt für cout
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    cout << "Hallo dort.\n";
    cout << "Hier ist 5: " << 5 << "\n";
    cout << "Der Manipulator endl beginnt eine neue Zeile.";
    cout <<
         endl;
    cout << "Hier kommt eine grosse Zahl:\t" << 90000 << endl;
    cout << "Hier ist die Summe von 8 + 5:\t" << 8+5 << endl;
    cout << "Hier ist ein Bruch:\t\t" << (float) 5/8 << endl;
    cout << "...und eine riesengrosse Zahl:\t";
    cout << (double) 8000*9000 <<
             endl;
    cout << "Vergessen Sie nicht, Michael Bergmann durch Ihren Namen "
            "zu ersetzen...\n";
    cout << "Michael Bergmann ist ein C++-Programmierer!\n";
}

Programmbeschreibung

• Zeile 8 bindet mit der Anweisung #include <iostream> die Datei iostream in den Quellcode ein. Das ist erforderlich, um cout und die verwandten Funktionen verwenden zu können.
• Zeile 16 zeigt den einfachen Einsatz von cout: Es wird einfach ein Zeichenstring ausgegeben. Das Symbol “/n” ist ein besonderes Formatierungszeichen (..ein sog. Escape-Code). Es teilt cout mit, das Zeichen für eine neue Zeile auf dem Bildschirm auszugeben.
• In Zeile 17 werden cout drei Werte übergeben, wobei die Werte voneinander durch einen Umleitungsoperator getrennt sind. Der erste Wert ist der String (= Zeichenkette) ”Hier ist 5: ” – beachten Sie das Leerzeichen nach dem Doppelpunkt. Dieser Raum ist Teil des Strings! Anschließend wird dem Umleitungsoperator der Wert 5 und das Zeichen für NeueZeile (immer in doppelten oder einfachen Anführungszeichen) übergeben. Damit wird insgesamt folgende Zeile: Hier ist 5: 5 an der Konsole ausgegeben. Da hinter dem ersten String kein NeueZeile-Zeichen kommt, wird der nächste Wert direkt dahinter ausgegeben. Dies nennt man auch “zwei Werte verketten” oder Konkatenation.
• Zeile 18 gibt eine Meldung aus und verwendet dann in Zeile 20 den Manipulator endl (= end line), um eine neue Zeile auf dem Bildschirm auszugeben. Die entspricht der Escape-Sequenz “\n”, beide bewirken hier das gleiche Resultat.
• Zeile 21 führt ein weiteres Formatierungszeichen, das “\t” ein. Damit wird ein Tabulatorsprung eingeführt, mit dem die Ausgaben der Zeilen 21 bis 24 bündig ausgerichtet werden.
• Zeile 22 zeigt, dass cout auch einfache Additionen verarbeiten kann. Den Wert 8 + 5 wird an cout weitergeleitet und dann als 13 ausgegeben.
• In Zeile 23 wird cout der Wert 5 / 8 (Division) übergeben. Mit dem Begriff (float) teilen Sie cout mit, dass das Ergebnis als Dezimalzahl ausgewertet werden soll (…man nennt das “Type-Casting“).
• In Zeile 25 übernimmt cout den Wert 8000 * 9000 (Multiplikation). Der Begriff (double) teilt cout mit, dass Sie das Ergebnis in wissenschaftlicher Notation wünschen.

Ist Ihnen bei der Formatierung des Quelltextes etwas aufgefallen? Genau! Es ist eigentlich nahezu egal, ob Sie einen
(…oder gleich alle!) Befehl(e) in eine Zeile schreiben, oder ob Sie Anweisungen und Befehle auf mehrere Zeilen verteilen. C++ ist formatfrei. Das bedeutet, dass Sie beim Erfassen des Quelltextes getrost eine gut lesbare Struktur verwenden dürfen – Ihr Programm wird durch das Hinzufügen oder Weglassen von Leerzeilen weder größer, noch schneller oder langsamer.