Das C-ABC: Stufenweise zum hohen C (2)

Die Sprache C ist maschinennah, übersichtlich, schnell - und wie Sie sehen werden, leicht zu erlernen.

Legen wir gleich voll los und vertiefen uns in die Verwendung von Variablen. Sie erinnern sich? Sie deklarieren Variablen, indem Sie den Variablentyp, gefolgt vom Variablenname, gefolgt von einem Semikolon angeben (z.B. »int nummer;«). C neigt zur Kürze. Deswegen erlaubt es Ihnen, Variablen des gleichen Datentyps zu einer einzigen Deklaration zusammenzufassen, z.B. »int a,b,c,d;«. In diesem Beispiel haben wir vier Integervariablen mit den Namen »a«, »b«, »c« und »d« deklariert.

Variablenzuweisungen lassen sich ebenfalls kompakter gestalten. Um beispielsweise zu der Variablen »a« den Wert 5 zu addieren, können Sie statt »a = a + 5;« die kompaktere Formulierung »a + = 5;« verwenden. Statt dem Wert 5 dürfen Sie ebenso eine weitere Variable und auch einen zusammengesetzten Ausdruck wie »b+c+5« verwenden. Analog verwenden Sie zum Subtrahieren eines Wertes von einer Variable die Anweisung »a -= 5;«. Zum Multiplizieren verwenden Sie »*=« und zum Dividieren »/=«.

Addieren Sie zu einer Variable den Wert 1, so gibt es in C zwei spezielle Additionsanweisungen, das Pre-Inkrement »++<variable>« und das Post-Inkrement »<variable>++«. Beide Formen erhöhen die angegebene Variable um 1. Beispielsweise erhöht die Anweisung »a++« die Variable a um 1. Auf die Unterschiede der beiden Formulierungen gehe ich an geeigneter Stelle ein. Für das Subtrahieren des Wertes 1 gibt es analog das Pre-Dekrement »--<variable>« und das Post-Dekrement »<variable>--«.

Wie Sie sehen, lassen sich in C Wertzuweisungen sehr kompakt halten. Wollen Sie beispielsweise das Ergebnis einer Operation in einer Variablen festhalten, aber gleichzeitig als Operand für eine weitere Operation verwenden, so schreiben wir bisher »a = 4 + 5; b = a + 2;«. Eine kürzere aber gleichwertige Version ist »b = (a = 4 + 5) + 2;«. Analysieren wir diese Anweisung: Zunächst erkennt der Compiler die in Klammern gesetzte Operation »a = 4 + 5«. Die Variable »a« erhält das Ergebnis der Addition 4+5 zugeordnet. Der Variablenwert von »a« wird in die Operation »b = a + 2;« eingesetzt. Die Variable »b« ist das Ergebnis der Addition von 9 und 2.

Neue Datentypen

Als Datentypen haben wir im ersten Teil »int« für ganzzahlige Werte bzw. Variablen und »float« für Fließkommavariablen kennengelernt. Doch C bietet dem Programmierer eine Reihe weiterer Datentypen.

In Tabelle 1 finden Sie die Schlüsselworte, mit denen Sie Daten eines elementaren Datentyps deklarieren können. Die Tabelle ist in zwei Teile gegliedert: Im oberen Teil finden Sie die elementaren Datentypen mit dem zugehörigen Schlüsselwort für die Deklaration. Die Schlüssel worte im unteren Teil sind lediglich Modifikatoren, mit denen Sie die elementaren Datentypen genauer bestimmen bzw. einschränken.

Da ist zunächst der Variablentyp »char« (zu Deutsch »Zeichen«). Variablen des Typs »char« sind 8 Bit breit und haben somit einen Wertebereich von -128 bis 127. Zeichen sind die elementaren Bausteine unserer Kommunikation mit dem Computer. Wir unterteilen die Zeichen in mehrere Kategorien: Buchstaben, Ziffern und Sonderzeichen. Daneben gibt es unsichtbare Zeichen. Diese »Zeichen« nennt man Steuerzeichen, da sie zur Steuerung von Ausgaben dienen. So gibt es Zeichen, um einen Ton auszugeben und am Drucker einen Seitenvorschub zu erreichen.

Um einer Zeichenvariable ein Zeichen zuzuordnen, gibt es zwei Wege: Zum einen setzen Sie das zuzuordnende Zeichen in einfache Anführungszeichen, andererseits geben Sie die Zeichennummer im Wertebereich von -128 bis 127 bzw. von 0 bis 255 an. C versteht dabei drei verschiedene Zahlensysteme: oktal (Zahlenbasis 8), dezimal (Zahlenbasis 10) und hexadezimal (Zahlenbasis 16). Bisher haben wir ausnahmslos die dezimale Notation verwendet. Für die oktale Notation verwenden Sie die Escape-Sequenz »\XXX«, wobei »XXX« eine dreistellige Oktalzahl ist. Hexadezimalzahlen haben das führende Symbol »Ox«. Um ein Zeichen über die »scanf«-Funktion einzulesen bzw. über die »printf«-Funktion auszugeben, verwenden Sie die Escape-Sequenz »%c«. In Listing 1 finden Sie einige Beispiele zum char-Variablentyp und den Zahlensystemen.

main()
{
    char c1,c2,c3,c4,c5,c6;
    cl = '-'    /* c1 enthält jetzt den Bindestrich */
    c2 = '\n';  /* c2 verursacht Zeilenvorschub */
    c3 = 'A';   /* c3 erhält das Zeichen A */
    c4 = '\101'; /* c4 enthält die Oktalzahl für 'A' */
    c5 = 65;    /*  Dezimalzahl für 'A' */
    c6 = 0x41;  /*  Hexadezimalzahl für 'A' */
    printf ( "%c%c%c%c%c%c",c1,c2,c3,c4,c5,c6) ;
}

Listing 1. Beispiele zur Zuordnung von Zeichen.

Mit Integer-Variablen hatten wir bereits Kontakt. Neben der Deklaration mit »int« gibt es die weiteren Varianten »unsigned int«, »short int« und »long int«, die Sie allerdings auch durch die kürzere Formen »unsigned«, »short« und »long« ersetzen können. Integer-Variablen, die den Modifikator »unsigned« besitzen, nehmen nur positive ganzzahlige Werte zwischen 0 und 65535 an. Deklarieren Sie eine Variable als »long«, so haben Sie den Wertebereich zwischen -2147483649 und 2147483648 zur Verfügung. Um dem Compiler eine Zahl als »long« zu verkaufen, hängen Sie der Zahl einfach ein »I« an, z.B. »231« und »OxIaOl«.

Schlüsselwort Bedeutung
char Zeichen (8 Bit)
int Ganze Zahl (16 Bit)
float Fließkommazahl
double Doppelt genaue Fließkommazahl
short Modifikator für int und double
long Modifikator für int
unsigned Modifikator für char und int

Tabelle 1. Die elementaren Datentypen von C

Zwar stellt der Datentyp »long« einen Wertebereich von beträchtlicher Größe bereit, doch etwa für mathematische Probleme sind Zahlen von höherer Genauigkeit erforderlich. Wir kennen bereits die einfachen Fließkommazahlen des Datentyps »float«. Eine noch höhere Genauigkeit bieten allerdings die »double float« - oder auch einfach nur als »double« formuliert.

Präprozesserbefehle

C besitzt eine Eigenschaft, die man in anderen Programmiersprachen vergeblich sucht: den Makro-Präprozessor. Schauen wir uns dazu Listing 2 an.

#define AUSGABE "\n\tNur C kennt Makros!" 
main()
{
    printf(AUSGABE);
}

Listing 2. Der Präprozessorbefehl für Makros: »#define«.

Lassen Sie dieses Beispiel laufen, sehen Sie - um eine Tabulatorposition eingerückt - den Text »Nur C kennt Makros«. Dieser ist aber offensichtlich nicht das Argument der printf-Funktion, wie es in unseren bisherigen Beispielen der Fall war. Vielmehr steht da ein geheimnisvolles »AUSGABE«. C weiß, was das bedeuten soll. Denn in der ersten Programmzeile haben wir dem Compiler mitgeteilt, was damit gemeint ist.

Mit »#define« können Sie beliebige Zeichenfolgen durch andere ersetzen. Damit haben Sie Gelegenheit, für Programmteile selbstgewählte Namen zu vergeben. In Listing 2 haben wir einfach die auszugebende Botschaft auf den Namen »AUSGABE« getauft. Wenn wir nun »Ausgabe« verwenden, weiß C, daß wir den String meinen. Das Format des »#define«-Präprozessorbefehls lautet:

#define <makro_name> zeichenfolge

Wollen Sie eigene Makros definieren, achten Sie darauf, daß Sie das »#« von »#define« unmittelbar am Anfang der Zeile stellen. Die für Makros zuständige Instanz heißt Präprozessor, weil sie vor dem Compiliervorgang durch den Quelltext geht und unter anderem nach »#define«-Anweisungen sucht.

#include "stdio.h"
#define AUFFORDERUNG "\nBitte ein Taste drücken"
#define AUSGABE "\nSie haben die Taste %c gedrückt" 
main()
{
    char eingabe;
    printf(AUFFORDERUNG); /* Text ausgeben */ 
    eingabe = getchar(); /* Zeichen einlesen */ 
    printf(AUSGABE,eingabe);
}

Listing 3. Der Präprozessorbefehl »#include«

Sehen sich nun Listing 3 an. Dieses Beispiel enthält eine weitere Präprozessoranweisung »#include«. Sie verknüpft den Inhalt einer anderen Datei mit der Quelltextdatei. Trifft der Präprozessor auf eine »#include«-Anweisung, so unterbricht er die Analyse des Quelltexts und sieht sich die hinter »#include« angegebene Datei an. Der Dateiname muß entweder wie im Listing 3 in Anführungszeichen oder zwischen den Zeichen '<' und '>' gesetzt sein. Der Compiler informiert sich über alle in der include-Datei enthaltenen Definitionen. Danach arbeitet er wieder das Hauptprogramm ab.

In C ist es üblich, oft benötigte Präprozessor-Definitionen in Dateien zusammenzufassen - den sog. Headerdateien. Diese Dateien besitzen deswegen oft die Endung ».h«. In Listing 3 haben wir die Datei »stdio.h« eingebunden. Sie enthält einige wesentlichen Definitionen für die Ein-/Ausgabe (stdio = Standard Input/Output). Die Funktion »getchar«, die wir mit der dritten Anweisung aufrufen, ist beispielsweise in dieser Headerdatei definiert.

Kontrollstrukturen

Mit dem furchteinflösenden Begriff »Kontrollstrukturen« bezeichnen Informatiker Sprachelemente, mit denen sich die Reihenfolge der Programmausführung beeinflussen läßt. Die am meisten verwendete Kontrollstruktur hilft zum Formulieren von Entscheidungen: if und if...eise. Damit geben Sie vor, was passieren soll, wenn ein Ausdruck wahr ist (if...) und was zu tun ist, wenn nicht (eise...). Die Syntax lautet: if (<ausdruck>) <anweisung1> oder if (<ausdruck>) <anweisung1> eise <anweisung2> Trifft das Programm auf das Schlüsselwort »if«, so prüft es, ob der in Klammern gesetzte Ausdruck wahr ist. Als Ausdruck verwendet man gewöhnlicherweise einen Vergleich einer Variable mit einem bestimmten Wert oder einer weiteren Variable. Ist der Vergleich wahr, dann wird der Anweisungsblock <anweisung1> ausgeführt. Ansonsten macht das Programm mit dem Anweisungblock <anweisung2> hinter dem Schlüsselwort »eise« weiter. Fehlt »eise <anweisung2>«, so schreitet das Programm zur nächsten Anweisung nach der if-Kontrollstruktur. Listing 4 zeigt die Verwendung der if-Anweisung.

main()
{
    int eingabe;
    printf("\nBitte die Zahl 123 eingeben: "); 
    scanf("%d",&eingabe);
    if (eingabe = 123) /* ist eingabe gleich 123? */ 
        printf("\Bravo, die richtige Eingabe."); 
    else /* Die Eingabe ist ungleich 123! */
        printf("\nSchlecht, die falsche Eingabe.");
}

Listing 4. Die if-else-Anweisung

Schauen wir uns Listing 4 genauer an: Der Vergleich lautet »eingabe==123«: Die Variable »eingabe« wird auf den Wert 123 geprüft. Als Vergleichsoperator haben wir »==« verwendet, der soviel wie »ist gleich« bedeutet. Weitere Vergleichsoperatoren finden Sie in Tabelle 2. Achten Sie darauf, daß Sie nicht den Zuweisungsoperator »=« und den Vergleichsoperator »==« verwechseln! Hat der Benutzer den Wert 123 eingegeben, so ist der Vergleich wahr und <anweisung1> wird ausgeführt; in unserem Fall erscheint die Bildschirmausgabe »Bravo, die richtige Eingabe«. Ist der eingegebene Wert ungleich 123, so wird stattdessen »eise <anweisung2>« abgearbeitet und die Nachricht »Schlecht, die falsche Eingabe« erscheint.

Für Vergleiche gibt es nur zwei Ergebnisse: wahr oder falsch. Da der Computer nur mit Zahlen arbeitet, stellt er die Ausdrücke »wahr« und »falsch« intern als Werte dar. Als wahr bezeichnet man einen Wert ungleich Null, als falsch den Wert Null. Führt das Programm einen Vergleich durch, so kodiert es intern das Ergebnis entweder als wahr oder falsch, also als 1 oder 0. Aus diesem Grund gibt auch der if-Aus-druck »if (eingabe)« einen Sinn. Als Ergebnis des fehlenden Vergleichs - denn »eingabe« ist ja kein Vergleich - verwendet die Ausdruckauswertung den Variableninhalt von »eingabe«. Ist die Variable »eingabe« ungleich Null, so ist der »Vergleich« wahr.

In diesem Zusammenhang läßt sich auch der Sinn der Unterteilung des Inkrements und des Dekrements von Variablen in Pre- und Post-Inkrement/Dekrement erklären. Beide Anweisungen »++a;« und »a++;« erhöhen den Wert der Variablen um 1. Verwenden Sie das Inkrement/Dekrement allerdings als Ausdruck in einem if-Vergleich (»if (++a)«), so führt ein Pre-In-krement/-Dekrement die Operation vor der Ausdrucksauswertung durch. Ein Post-Inkrement/-Dekrement führt die Operation nach dem Vergleich durch. Hat beispielsweise die Variable »a« den Wert 0, so ist das Ergebnis des Ausdrucks »if (++a)« wahr, denn die Variable wird zuerst auf den Wert 1 erhöht und der Ausdruck somit wahr. Verwenden Sie stattdessen »if (a++)«, so bekommt die Ausdrucksauswertung zuerst den Wert 0 der Variablen, »a« wird erst anschließend auf 1 erhöht.

Für <anweisung1> und <anweisung2> haben wir in Listing 4 jeweils nur eine C-Anweisung verwendet. Doch oft reicht es nicht aus, auf eine Entscheidung mit nur einer Anweisung zu reagieren. Deswegen erlaubt Ihnen C, für <anweisung1> und <anweisung2> Anweisungsblöcke zu verwenden. Wie Sie bereits wissen, sind Anweisungsblöcke zwischen den beiden Symbole »{« und »}« eingebettet. Listing 5 demonstriert eine verschachtelte if-else-Entscheidung.

arg1 > arg2 arg1 größer als arg2
arg1 < arg2 arg1 kleiner als arg2
arg1 >= arg2 arg1 größer oder gleich arg2
arg1 <= arg2 arg1 kleiner oder gleich arg2
arg1 == arg2 arg1 gleich arg2
arg1 != arg2 arg1 ungleich arg2

Tabelle 2. Die Vergleichsoperatoren von C

main()
{
    int eingabe;
    printf("\nBitte das Passwort eingeben: "); 
    scanf ("%d", &eingabe); 
    if (eingabe = 123) /* if #1 */
    {
        printf("\nBravo, die richtige Eingabe!"); 
        printf("\nNun den zweiten Teil des Passworts: "); 
        scanf("%d",&eingabe); 
        if (eingabe == 456) /* if #2 */
            printf("\nOK. Sie dürfen passieren...");
        else
            printf("\nSchlecht, die falsche Eingabe");
    }
    else
        printf("\nSchlecht, die falsche Eingabe");
}

Listing 5. Eine erweiterte it-Anweisung mit Verschachtelung

Das Listing demonstriert auch, daß in den Anweisungsblöcken weitere if-Anweisungen folgen dürfen. Der Fach-Jargon nennt dies Verschachtelung. Gehen wir zu einer weiteren Kontrollstruktur über: der Mehrfachauswahl mit »switch«. Konkretes Beispiel: Sie wollen einen Passwortschutz für ein Programm schreiben, der mehreren Benutzern mit jeweils unterschiedlichen Kennummern Zugang gewährt. Mit der eben vorgestellten if-Anweisung ist ein solches Vorhaben zwar durchführbar, doch schon mit mehr als drei Benutzern wird das Programm zu unübersichtlich. Hierzu eignet sich die Mehrfachauswahl mit den Schlüsselwörtern »switch«, »case« und »default«. Listing 6 erreicht ein Passwortsystem für zunächst drei Benutzer.

main()
{
    int eingabe; 
    printf("\nBitte Ihre Kennr.ummer eingeben: "); 
    scanf("%d", &eingabe);
    switch (eingabe) /* eingabe auf Werte prüfen */
    {
        case 123: /* eingabe ist gleich 123? */ 
            printf("\nBenutzer 1");
            break;
        case 456: /* eingabe ist gleich 456? */ 
            printf("\nBenutzer 2"); 
            break;
        case 789: /* eingabe ist gleich 789? */ 
            printf("\nBenutzer 3"); 
            break;
        default: /* eingabe hat anderen Wert */ 
            printf("\nSie sind kein Benutzer!"); 
            break;
    }
}

Listing 6. Mehrfachauswahl mit »switch«

Was macht das Listing? Zunächst erwartet das Schlüsselwort »switch« eine in Klammern gesetzte Variable. Diese überprüft der darauffolgende spezielle Anweisungsblock durch das Schlüsselwort »case« auf bestimmte Werte. Jedem »case« folgt unmittelbar ein Wert und ein Doppelpunkt. Stimmt dieser Wert mit dem Variablenwert überein, so werden die auf das entsprechende »case« folgenden Anweisungen ausgeführt. Stößt das Programm dabei auf das Schlüsselwort »break«, so beendet es die switch-Kontrollstruktur. Beachten Sie, daß auch »break« als besondere Betonung ein abschließendes Semikolon benötigt. Um beispielsweise eine Variable auf zehn Werte zu prüfen und darauf entsprechend zu reagieren, verwenden Sie zehn »case«-Anweisungen. Doch was, wenn wir auch auf nicht aufgeführte Werte mit einer pauschalen Anweisung reagieren wollen? Hierzu steht uns das Schlüsselwort »default:« zur Verfügung (siehe Listing 6). Stimmt der Variablenwert mit keinem case-Wert überein, führt das Programm die auf »default« folgenden Anweisung aus.

Geben Sie in Listing 6 als Eingabe beispielsweise den Wert 456 ein, so entspricht dies dem Wert des zweiten »case« (case 456:). Das Programm springt nun auf die dem zweiten »case« folgenden Anweisung; der Text »Benutzer 2« wird ausgeben. Nun folgt das »break«-Schlüsselwort. Das Programm verläßt daraufhin die switch-Kontrollstruktur. Da keine weiteren Anweisungen nach der switch-Kontrollstruktur folgen, endet das Programm.

Um auf mehrere Werte mit jeweils den gleichen Anweisungen zu reagieren, dürfen Sie auch mehrere »case« ohne »break;« hintereinanderstellen (siehe Listing 7).

switch (eingabe)
{
    case 123: 
    case 456: 
    case 789:
        printf("\nSie sind Benutzer!"); 
        break; 
    default:
        printf("\Kein Benutzer!"); 
        break;
}

Listing 7. Auf mehrere Werte pauschal reagieren

Die nächsten Kontrollstrukturen, dienen zur wiederholten Ausführung von Anweisungen. Informatiker unterteilen die Gattung der Programmschleifen in verschiedene Unterarten: Zählschleifen, abweisende und nichtabweisende Schleifen.

Zählschleifen sind Schleifen, bei denen Sie angeben, wie oft sich eine Anweisung bzw. ein Anweisungsblock wiederholen soll. Dazu benutzen Sie sog. Zählvariablen. Diese erhöhen oder erniedrigen sich in jedem Schleifendurchlauf um einen bestimmten Betrag, solange, bis die Variable einen vorgegebenen Wert erreicht hat. C stellt uns als Zählschleife die »for«-Kontrollstruktur zur Verfügung. Diese kann folgende Bestandteile enthalten:

for(< initialisierung >; < kontrollbedingung >;
< reinitialisierung > )
< anweisung >

Im Initialisierungteil führen Sie alle Variablenzuweisungen durch, um die Zählvariablen auf die Startwerte zu setzen. Kontrollbedingungen sind gewöhnlich Vergleiche der Zählvariablen mit den Endwerten. Im Re-Initialisierungsteil erhöhen bzw. erniedrigen Sie die Zählvariablen. In Listing 8 finden Sie ein Beispiel zur for-Schleife.

main()
{
    int zaehler;
    for (zaehler = 1; zaehler <= 10; zaehler++)
        printf(n\nSchleifendurchlauf %d",zaehler);
}

Listing 8. Eine typische for-Schleife

Als Initialisierung haben wir im Listing 8 der Variablen »zaehler« den Wert 1 zugeordnet. Die Kontrollbedingung läßt die Schleife solange ausführen, solange die Variable »zaehler« kleiner oder gleich dem Wert 10 ist. Im Re-Initialisierungsteil erhöhen wir »zaehler« um 1. Die Schleifenanweisung gibt uns die Schleifendurchlaufsnummer auf dem Bildschirm aus. Im Initialiserungs-, Kontrollbedings- und Re-Initialisierungsteil können Sie jeweils mehrere Anweisungen verwenden. Diese müssen Sie durch ein Komma voneinander trennen (siehe Listing 9).

main()
{
    int i,j;
    for (i = 0, j = 1; i < 10; i = i+1) 
        printf("\nj ist %d",j += j);
}

Listing 9. Eine for-Variante

Ebenso dürfen Sie auch auf Schleifenelemente verzichten. In diesem Fall stehen die Semikolons unmittelbar hintereinander (siehe Listing 10). Beachten Sie, daß Listing 9 keine Kontrollbedingung enthält. Das bedeutet mit anderen Worten, daß die Schleife nie abbricht. Führen Sie dieses Beispiel aus, so hilft nur noch ein Griff zum Reset-Schalter.

for (i = 0; ; i = i+1) ;

Listing 10. Wir verwenden keine Kontrollbedingung und keine Anweisung

Gehen wir nun zu einer weiteren Programmschleife über: die »while«-Schleife. Dieser Schleifentyp wird »abweisend« genannt, weil er die Kontrollbedingung überprüft, ehe er sich an die Ausführung der Anweisung bzw. des Anweisungsblocks macht. Ist diese Bedingung schon zu Beginn falsch, dann kommt es gar nicht zur Ausführung der Anweisung: C fährt einfach hinter der while-Schleife mit der Arbeit fort. Dieses Verhalten stellen Sie übrigens auch bei der for-Schleife fest: Ist die Zählvariable schon zu Beginn größer als der Endwert (z.B. for (i = 10; i < 10; i = i+1), so kommt es zu keinem einzigen Schleifendurchlauf. Die while-Schleife hat folgenden Aufbau:

while (< kontrollbedingung >)
< anweisung >

Eine Variante der while-Schleife ist die do-while-Schleife. Diese ist jedoch nichtabweisend, das heißt, sie überprüft die Kontrollbedingung erst nach der Ausführung des Anweisungsblocks. Die do-while-Schleife ist folgendermaßen aufgebaut

do
< anweisung >
while (< kontrollbedingung >);

Normalerweise entscheidet die Kontrollbedinung, wann eine Schleife abgebrochen wird. Manchmal ist es aber erforderlich, eine Schleife zu verlassen in Abhängigkeit von Bedingungen, die nicht der Schleifenkopf kontrolliert. Für diese Art des vorzeitigen Ausstiegs hält C die Anweisungen »break« und »continue« bereit.

Taucht »break« in einer Schleife auf, dann wird diese sofort verlassen; es erfolgt kein erneuter Durchgang der Schleife. Wir kennen »break« schon von der switch-Kontrollstruktur.

Auch dort erzwingt ein »break« das sofortige Verlassen der Schleife. Alle darauffolgenden Anweisungen innerhalb der Schleife werden ignoriert.

Die continue-Anweisung bewirkt ebenfalls ein sofortiges Verlassen der Schleife, diesmal jedoch für einen erneuten Durchlauf, »continue« verhindert lediglich, daß folgende Anweisungen im Schleifenkörper ausgeführt werden. Dazu ein Beispiel: In Listing 11 verlassen Sie mittels »break« die Endlosschleife, sobald Sie die Taste <!> drücken. Drücken Sie eine andere Taste als die Leertaste, so erzwingt »continue« einen erneuten Schleifendurchlauf.

#include "stdio.h"
main()
{
    char c;
    while (1) {
        c = getchar(); 
        if (c == '!')
            break; 
        if (c != ' ') 
            continue;
        printf("\nSie haben die Leertaste gedrückt");
    }
}

Kursübersicht

Teil 1: Die Hauptfunktion, Bildschirm-Ein-/Ausgabe, einfache Datentypen, Grundrechenarten

Teil 2: Datentypen, Kontrollstrukturen, Präprozessor

Teil 3: Funktionen, Operatoren, Arrays, Strukturen

Teil 4: Module, Standard-C-Funktionen, Assembler und C, TOS-Funktionen

Teil 5: C und GEM

Teil 6: Programmprojekt: GEM-Anwendung


Martin Backschat
Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]