2. Einführungsbeispiel eines Programms in C

Transkript

1 2. Einführungsbeispiel eines Programms in C Wir lernen den allgemeinen Aufbau eines C-Programms kennen. Sämtliche kleineren C-Programme besitzen nämlich (glücklicherweise) einen recht ähnlichen Aufbau, sodaß man sich für den Anfang einen allgemeinen Rahmen erstellen könnte, der nur noch geringfügig zu modifizieren ist. Ein allererstes C-Programm Noch werden keine gewaltigen Probleme gelöst. Das Programm erscheint nicht nur trivial, dies ist es auch man hat nämlich vergleichsweise wenig davon. Es sieht so aus: void main() { printf("es geht los!\n"); } Tippt man dieses Programm ein und zwingt den Compiler zu übersetzen und den Linker es in einer ausführbaren Programmdatei zusammenzubinden (erkennbar am Kürzel.exe ), kann man es durch Anklicken ausführen lassen. Irgendwo erscheint dann auf dem Bildschirm der Text in einem schwarzen(!) Fenster mit weißen Buchstaben Es geht los womit das Programm auch schon ausgeführt, d. h. beendet ist. Man erkennt es daran, daß wieder die vertraute Entwicklerumgebung erscheint. Genaugenommen hat man gar nichts gesehen es ging viel zu schnell. Bevor wir es ein wenig modifizieren, um wenigstens einige sichtbare Resultate auf dem Bildschirm zu erhalten, sehen wir uns das Trivialbeispiel etwas genauer an, um seine Grundelemente zu studieren. Die #include-anweisung Diese Anweisung steht zu Beginn des Programms. Ihre eigentliche Bedeutung erfahren wir erst beim Durcharbeiten der weiteren Sprachelemente, wenn der Programmkopf modifiziert wird. Zunächst sei folgendes dabei festgehalten: C ist eine Programmiersprache mit einem sehr kleinen Sprachumfang. Selbstselbstverständlich anmutende Funktionalitäten wie Ausgabe eines Textes auf den Bildschirm sind in der Sprache selbst nicht enthalten. Sie steht in einer externen Programmbibliothek und wird erst durch den C- 1

2 Compiler zum Programm hinzugefügt. Allerdings muß der Compiler wissen, wie diese Funktion verwendet wird, denn sonst kann er keine möglichen Fehler feststellen. Diese Information erhält er aus der Textdatei stdio.h (das Kürzel h verdeutlicht, daß es sich nicht um ein Quellprogramm handelt beim Borland-Compiler (also mein eigener auf meinem eigenen Rechner) Pfad C:\Programme\Borland\CBuilder4\Include die mit WordPad geöffnet werden kann und so beginnt: /* stdio.h */ Definitions for stream input/output. Sie wird beim Compilieren so in das Programm integriert, als wäre sie vom Anwender eingegeben worden. Der Dateiname steht übrigens für Standard Input Output. Im Moment halten wir (leicht sinnentleert) fest: hat immer am Anfang (unverändert) zu stehen. Die main-funktion Die zweite Zeile lautet void main(). Für sie gilt wie für die #include-anweisung als feststehende Verbindung immer übernehmen, deren Sinn es ist, gewissermaßen den Rahmen eines C-Programms festzulegen. Wir halten nur fest: Jedes C-Programm beginnt mit main. Die Zeile void main() kennzeichnet also den Beginn des Programms. Man spricht normalerweise vom Hauptprogramm. Anmerkung: Genaugenommen ist main() eine Funktion, die hier deklariert und definiert wird das Hauptprogramm als Funktion. Sobald wir den Teil der Funktionen i. A. kennengelernt haben, werden wir über den dort definierten Aufbau die analoge Struktur von main() erkennen. Eine Funktion im üblichen mathematischen Sinne hat normalerweise einen Argument- und Funktionswert. In der Programmierung wird dieser Sachverhalt dahingehend benutzt, daß Funktionen einen Teil des Programms übernehmen sei es, weil sie öfters ausgeführt werden müssen, sei es, um die Übersichtlichkeit zu erhöhen. Dabei werden der Funktion bestimmte Werte 2

3 übergeben dies entspricht dem Argumentwert einer mathematischen Funktion -, diese durch die Funktion verarbeitet, und letztendlich wird entsprechend dem Funktionswert ein Wert zurückgegeben. main ist der Funktionsname. Es gibt keine Argumentwerte, die entgegengenommen werden. Daher folgt auf main das Klammerpaar ( ). Ebenso wenig gibt main einen Wert zurück. Dies kennzeichnet das Wort void (engl. leer, nichtig ). Geschweifte Klammern Das eigentliche Programm der Teil, dessen Abfolge von Anweisungen dem Rechner mitteilt, was er zu tun hat steht in geschweiften Klammern. Genaugenommen besteht dieser Daseinszweck der geschweiften Klammern darin, Anfang und Ende des Programms oder eines Programmblocks zu kennzeichnen. Dies bedeutet, daß auf eine geöffnete geschweifte Klammer irgendwann eine geschlossen folgen muß. Im Allgemeinen kann man mit geschweiften Klammern mehrere Anweisungen zu einem Block zusammenfassen, der aus einer Folge von Anweisungen besteht. Das Hauptprogramm stellt einen solchen Block dar und ist daher in geschweifte Klammern einzuschließen. In unserem (langweiligen) Fall besteht das Programm aus nur einer einzigen Anweisung: Der Ausgabebefehl printf Die Zeile, die mit printf beginnt, übernimmt die Bildschirmausgabe. Der Text, der ausgegeben werden soll, folgt in Klammern und wird von Anführungszeichen eingeschlossen. Strenggenommen ist printf keine Anweisung, sondern auch eine Funktion, aber im Moment wollen wir uns nicht mit Spitzfindigkeiten überschlagen. Zu beachten ist: Die Hochkommata werden nicht mit ausgegeben; ihr Zwecks besteht tatsächlich nur darin, Anfang und Ende des auszugebenden Textes zu markieren, damit der Compiler diesen als Text erkennen kann. In unserem Beispiel erscheint im Text noch der etwas mystisch anmutende Zusatz \n am Ende des Textes (man achte darauf, daß dieser Teil immer noch innerhalb der Hochkommata steht!). Der Rückstrich \ kennzeichnet die nachfolgenden Symbole nicht mehr als auszugebenden Text, sondern als Sonderzeichen für die Art der Textausgabe. n ist ein Steuerzeichen und sorgt für Zeilenumbruch. Das heißt, daß nach Schreiben des Textes auf dem Bildschirm der Cursor auf die nächste Zeile springt. 3

4 Als Variation ist auch möglich printf("\n Es geht los! \n ) Es erfolgt ein Zeilenvorschub, auf die nächste Zeile kommt Es geht los (also alles, was auf \n folgt) und wird mit Zeilenumbruch abgeschlossen. printf("es geht \n los \n ) Es geht steht auf der ersten Zeile, los auf der zweiten, der Cursor bleibt auf der dritten. Also: \ ( Rückstrich oder backslash ) kennzeichnet das nachfolgende Symbol als Steuerzeichen. Das Steuerzeichen n für Zeilenumbruch haben wir bereits kennengelernt. Es gibt folgende Steuerzeichen: Symbol Funktionalität \b backspace (ein Zeichen zurück positionieren) \f Seitenvorschub (formfeed bei Druckerausgabe) \n Zeilenvorschub und Umbruch (carriage return) \r Carriage return \t Tabulator \xxx oktale Ziffernkombination Das Semikolon auf den Ausgabebefehl printf folgt schließlich ein Semikolon. Welchen Zweck hat dieses? Es gilt nicht die Regel, daß jede Programmzeile automatisch mit einem Semikolon enden muß siehe die include-anweisung oder die Zeile void main(). Der Sinn liegt daran, dem Compiler mitzuteilen, daß ein auszuführender (und hoffentlich ausführbarer) Befehl vorliegt. Weder include noch main sind ausführbare Befehle. Grundsätzlich: jeder Befehl ( Anweisung oder Statement ) wird in C mit einem Semikolon abgeschlossen. 4

5 Groß- und Kleinschreibung Der Compiler untersucht nicht nur die korrekte Klammerung und Setzen des Semikolons, auch bei der Groß- und Kleinschreibung ist er sehr festgelegt. Die Anweisung printf muß immer klein geschrieben sein. PRINTF wird als Fehler deklariert (noch besser: printf). Ebenso könnte man auf die Idee kommen, statt void Void zu schreiben. Doch auch hier wird der Compiler Schwierigkeiten machen. void ist ein Wort, das im Gegensatz zu printf zum Sprachumfang von C gehört. Es ist ein sog. reserviertes Wort. Reservierte Wörter müssen klein geschrieben werden. Format / Programmierstil Unser simples Erstprogramm kann auch gnadenlos in einer Zeile geschrieben werden dieses ist dem Compiler völlig gleichgültig. void main(){printf("es geht los!\n");} Oder man verteilt willkürlich ein paar Leerzeichen, ohne dabei vorhandene Worte zu zertrennen. void main( ){ printf ( "Es geht los!\n" );} Der Compiler akzeptiert auch das. Doch ob das Programm damit von der optischen Gestaltung her auch lesbarer ist, bleibt mehr als zweifelhaft. Die Formatierung bleibt zwar völlig dem Programmierer überlassen, doch im Sinne eines guten Programmierstils zwecks Erhöhung der Les- und damit Wartbarkeit eines Programms ist eine Strukturierung wie eingangs vorgegeben äußerst empfehlenswert. Diese rechnet sich insbesondere bei sehr komplexen Programmen (Das sind die, die auch wirklich etwas tun sollen!). Zusammenfassung Zu Beginn immer include-anweisung Hauptprogramm mit void main() einleiten und Anweisungsblock in geschweifte Klammern einschließen. Jede Anweisung muß mit einem Semikolon abgeschlossen werden. Auf Groß- und Kleinschreibung achten! Reservierte Wörter werden immer klein geschrieben. Strukturierung erleichtert Lesbarkeit. 5

6 Wir bekommen allerdings nicht sonderlich viel zu sehen von unserem Progrämmle. Variation: void main() { printf("es geht los\n"); getchar(); } Die zusätzliche Zeile getchar() erwartet die Eingabe eines Symbols und sorgt dafür, daß das Programm an der Stelle so lange anhält, bis die Eingabe erfolgt ist. Mithin bleibt die darüber befindliche Zeile Es geht los auch erst einmal auf dem Bildschirm sichtbar. Kleine Anmerkung zu den Compilern Der Borland-Compiler läßt, falls der getchar()-aufruf weggelassen wird, gnadenlos schnell die Konsole mit dem Inhalt des Programmablaufs durchrauschen. Man sieht auf dem Bildschirm nur einmal eine schwarze Fläche vorüberhuschen, und das war's dann auch schon. Der Windows Visual C++ - Compiler ist immerhin so nett und fragt nach Durchlauf, ob man denn abbrechen möchte. Ist allerdings eine ausführbare Datei erzeugt (Kürzel exe ), dann rattert diese bei Anklicken genauso gnadenlos durch wie man es vom Borland-Compiler her gewöhnt ist. Noch einige Anmerkungen und Beispiele zu den Steuerzeichen: /*****************************************************************************/ /* Ausgabe einer Zeichenkette mittels diverser Steuerzeichen */ /*****************************************************************************/ void main() { /* Ausgabe mit Steuerzeichen \n */ printf("ausgabe\n"); printf("mit\n"); printf("zeilenumbruch\n"); printf("nach\n"); printf("jedem\n"); printf("wort\n"); /* Ausgabe mit Steuerzeichen \b */ printf(" r\b\b"); printf("e\b\b"); printf("t\b\b"); 6

7 printf("u\b\b"); printf("p\b\b"); printf("m\b\b"); printf("o\b\b"); printf("c\n"); /* Ausgabe mit Steuerzeichen \r */ printf("handballmannschaft\r"); printf("fuss"); /* Ausgabe mit Steuerzeichen \t */ printf("\nspalte1\tspalte2\tspalte3"); printf("\neins\tzwei\tdrei"); printf("\nlinks\tmitte\trechts\n"); } getchar(); Das Programm erzeugt im ersten Teil die Ausgabe: Ausgabe mit Zeilenumbruch nach jedem Wort \n bewirkt, daß der Cursor an den Anfang der nächsten Zeile geht. Die nachfolgende Ausgabe ist Computer \b bewirkt, daß der Cursor auf eine Position zurückgesetzt wird. Im Programm wird durch \b\b bewirkt, daß der Cursor vor den gerade geschriebenen Buchstaben gesetzt wird. Zunächst werden sieben Leerzeichen, gefolgt von einem r geschrieben dem letzten Buchstaben des Wortes Computer. \b setzt den Cursor um ein Zeichen zurück, also auf den Buchstaben r. Das darauffolgende Steuerzeichen \b setzt den Cursor damit vor den Buchstaben r. Damit kann der vorletzte Buchstabe e geschrieben werden. Die Folge \b\b setzt den Cursor wiederum vor das e usw. bis schließlich der Zeilenanfang zwecks Schreibens des C erreicht ist. Schließlich die Ausgabe Fussballmannschaft. \r bewirkt, daß der Cursor an den Anfang der Zeile geht. Damit können die ersten vier Buchstaben Hand durch Fuss überschrieben werden. 7

8 \t sorgt für eine in Spalten geordnete Ausgabe ( Tabulator ): Spalte 1 Spalte 2 Spalte 3 eins zwei drei links Mitte rechts Ob ein sinnvolles Programm oder nicht ist eine andere Frage. Man weiß aber wenigstens: Es gibt diese Steuerzeichen. 8