Anweisung (Programmiersprache C)

Die hier gegebenen Informationen stützen sich auf den Standard der Sprache C (C99). Eigenschaften, die mit diesem Standard neu eingeführt wurden, werden im folgenden besonders angegeben.

Anweisungen und Blöcke sind Thema des Kapitels 6.8 Statements and blocks in C99. Dieses Kapitel ist Vorbild für diese Seite. Dabei soll jedoch nicht eine einfache Übersetzung des Standards wiedergegeben werden. Vielmehr ist es Ziel, Anweisungen getreu dem Standard zu erklären.

Inhalt

1 Benannte Anweisung 2 Zusammengesetzte Anweisung 3 Ausdrucks-Anweisung 3.1 Leere Anweisung 4 Verzweigungen 4.2 if 4.3 switch 5 Schleifen 5.4 while 5.5 do 5.6 for 6 Sprung-Anweisungen 6.7 goto 6.8 continue 6.9 break 6.10 return 7 Anweisung 8 Block

Benannte Anweisung

Syntax:

Bezeichner : Anweisung
case konstanter Ausdruck : Anweisung
default : Anweisung

Siehe auch: switch.

Der Bezeichner der benannten Anweisung kann in der gesamten Funktion angesprochen werden. Sein scope (Anwendungsgebiet) ist die Funktion. Dies bedeutet, dass der Bezeichner in einer goto-Anweisung noch vor seiner Deklaration verwendet werden kann.

Siehe auch: goto, if

Zusammengesetzte Anweisung

Syntax (C89):

{ declaration-listopt statement-listopt }

Deklaration
declaration-list Deklaration

Anweisung
statement-list Anweisung

{ block-item-listopt }

block-item
block-item-list block-item

Deklaration
Anweisung

Zusammengesetzte Anweisungen dienen hauptsächlich dazu, mehrere Anweisungen als eine syntaktische Anweisung darzustellen. So verlangen viele Anweisungen eine Anweisung als Sub-Anweisung. Sollen jedoch mehrere Anweisungen als Sub-Anweisung angegeben werden, so steht oft nur der Weg zur Verfügung, diese Anweisungen als eine Anweisung zusammenzufassen.

Wesentliches Merkmal der Syntax zusammengesetzter Anweisungen sind die umschließenden geschweiften Klammern ({}). Bei Anweisungen, welche Sub-Anweisungen erwarten, wie beispielsweise Schleifen oder Verzweigungen, werden geschweifte Klammern so häufig eingesetzt, dass leicht der falsche Eindruck entsteht, sie seien Teil der Syntax der Anweisung. Lediglich die Syntax einer Funktions-Definition verlangt (in C99) die Verwendung einer zusammengesetzen Anweisung.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if (argc>1)
 printf("Es wurden %d Parameter angegeben.\
", argc-1);
 printf("Der erste Parameter ist '%s'.\
", argv[1]);

 return 0;
}

Das eben gezeigte Beispiel lässt sich übersetzen, jedoch ist sein Verhalten nicht das Gewünschte. Der erste Parameter der Applikation soll nur ausgegeben werden, wenn er angegeben wurde. Jedoch wird nur die erste printf-Anweisung bedingt ausgeführt. Die zweite printf-Anweisung (eine Ausdrucks-Anweisung) wird stets ausgeführt, auch wenn die Formatierung des Quelltextes einen anderen Eindruck vermittelt. Repräsentiert der Ausdruck argv[1] keinen gültigen Zeiger, so führt seine Verwendung beim Aufruf der printf-Funktion zu einem undefinierten Verhalten der Applikation.

Siehe auch: if

Es soll also auch der zweite Aufruf von printf nur dann erfolgen, wenn mindestens ein Parameter angegeben wurde. Dies kann erreicht werden, indem beide (Ausdrucks-)Anweisungen zu einer Anweisung zusammengesetzt werden. So arbeitet das folgende Beispiel wie gewünscht.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if (argc>1)
 {
 printf("Es wurden %d Parameter angegeben.\
", argc-1);
 printf("Der erste Parameter ist '%s'.\
", argv[1]);
 }

 return 0;
}

In zusammengesetzten Anweisungen können neue Bezeichner deklariert werden. Diese Bezeichner gelten ab dem Zeitpunkt ihrer Deklaration und bis zum Ende des sie umschließenden Blocks. Die wesentliche Änderung von C89 zu C99 ist, daß in C89 alle Deklarationen vor allen Anweisungen stehen mussten. Im aktuellen Standard C99 ist dieser Zwang aufgehoben.

Ausdrucks-Anweisung

Syntax:

Ausdruckopt ;

Beispiel:

include 

int main(int argc, char *argv[])
{
 int a = 1, b = 2, c; /* Deklarationen */

 c = a + b; /* Ausdrucks-Anweisung */
 printf("%d + %d = %d\
",a,b,c); /* Ausdrucks-Anweisung */

 return 0; /* Sprung-Anweisung */
}

In der ersten Ausdrucks-Anweisung c = a + b; wird der Ausdruck c = a + b mit seinem Teilausdruck a + b ausgewertet. Als Seiteneffekt wird sie Summe aus den Werten in a und b gebildet und in dem Objekt c gespeichert. Der Ausdruck der zweiten Ausdrucks-Anweisung ist der Aufruf der Funktion printf. Als Nebeneffekt gibt diese Funktion einen Text auf der Standardausgabe aus. Häufige Ausdrucks-Anweisungen sind Zuweisungen und Funktionsaufrufe.

Leere Anweisung

void foo (char * sz)
{
if (!sz) goto ende;

/* ... */
while(getchar() != '\
' && !feof(stdin))
	;

/* ... */ 
ende: ;
}

Verzweigungen

if

if (Ausdruck) Anweisung
if (Ausdruck) Anweisung else Anweisung

Beispiel:

#include 

int main(int argc, char *argv[])
{
 if(argc>1)
 printf("Erster Parameter: %s\
", argv[1]);

 return 0;
}

Im vorangegangenen Beispiel prüft das Programm, ob mindestens ein Parameter dem Programm übergeben wurde und gibt ggf. diesen Parameter aus. Wurde jedoch kein Parameter dem Programm übergeben, so wird die (Ausdrucks-)Anweisung printf("Erstes Argument: %s\ ", argv[1]); nicht ausgeführt.

Soll auch auf den Fall eingegangen werden, dass der Kontrollausdruck 0 ergeben hatte, so kann die zweite Form der if-Anweisung verwendet werden. Im folgenden Beispiel genau eine der beiden Sub-Anweisungen ausgeführt.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if(argc>1)
 printf("Erster Parameter: %s\
", argv[1]);
 else
 puts("Es wurde kein Parameter übergeben.");

 return 0;
}

Die if-Anweisung stellt, wie der Name schon sagt, eine Anweisung dar. Daher kann eine if-Anweisung ebenso als Sub-Anweisung einer anderen Anweisung verwendet werden. Wird eine if-Anweisung als Sub-Anweisung einer anderen if-Anweisung verwendet, so ist darauf zu achten, dass sich ein eventuell vorhandenes else stets an das voranstehende if bindet.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if(argc>1)
 if(argc == 2)
 puts("Es wurde genau ein Parameter übergeben.");
 else
 puts("Es wurde kein Parameter übergeben.");

 return 0;
}

Die Formatierung des Quelltextes im letzten Beispiel erweckt den Eindruck, dass der Text Es wurde kein Argument übergeben. nur dann ausgegeben wird, wenn der Ausdruck argc>1 den Wert 0 ergibt. Jedoch ist Ausgabe des Textes davon abhängig, ob der Ausdruck argc == 2 den Wert 0 ergibt. Somit wird beim Fehlen eines Parameters kein Text ausgegeben und im Fall von mehreren Parametern erhalten wir die Fehlinformation, dass keine Parameter übergeben worden seien.

Soll das gewünschte Verhalten erreicht werden, so kann die if-Anweisung, welche die erste Sub-Anweisung darstellt, durch eine zusammengesetzte Anweisung ersetzt werden. Noch einmal auf deutsch: sie kann geklammert werden. So findet im folgenden Beispiel das Schlüsselwort else vor sich eine zusammengesetzte Anweisung und vor dieser Anweisung jenes if, welches mit dem Kontrollausdruck argc>1 behaftet ist.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if(argc>1)
 {
 if(argc == 2)
 puts("Es wurde genau ein Parameter übergeben.");
 } else
 puts("Es wurde kein Parameter übergeben.");

 return 0;
}

Ebenso wird die zusammengefasste Anweisung verwendet, wenn mehrere Anweisungen bedingt ausgeführt werden sollen. Da die if-Anweisung stets nur eine Anweisung als Sub-Anweisung erwartet, können zum bedingten Ausführen mehrerer Anweisungen, diese wiederum geklammert werden.

Im nächsten Beispiel findet das letzte else als erste Sub-Anweisung eine if-Anweisung mit einem else-Zweig vor. Diese (Sub-)Anweisung ist abgeschlossen und kann nicht mehr erweitert werden. Daher kann sich an eine solche if-Anweisung das letzte else nicht binden. Es gibt keine Form der if-Anweisung mit zwei else-Zweigen. Somit arbeitet das folgende Programm auch ohne Klammern wie erwartet.

Beispiel:

include 

int main(int argc, char *argv[])
{
 if(argc>1)
 if(argc == 2)
 puts("Es wurde genau ein Parameter übergeben.");
 else
 puts("Es wurden mehr als ein Parameter übergeben.");
 else
 puts("Es wurde kein Argument übergeben.");

 return 0;
}

Im letzten Beispiel zum Thema der if-Anweisung soll noch gezeigt werden, wie sich ein Programm verhält, bei dem in eine Sub-Anweisung über einen Sprung aufgerufen wird.

Beispiel:

include 

int main(void)
{
 goto marke;

 if (1==2)
 marke: puts("Ich werde ausgegeben.");
 else
 puts("Ich werde nicht ausgegeben!");

 return 0;
}

Obwohl der Ausdruck 1==2 offensichtlich den Wert 0 liefert, wird der else-Zweig nicht ausgeführt.

switch

Syntax:

switch (Ausdruck) Anweisung

Der Ausdruck muß einen ganzzahligen Datentypen (integer) haben. Er ist der Kontrollausdruck. Der ganzzahlige Datentyp des Kontrollausdrucks ist eine Einschränkung gegenüber der if-Anweisung, die in dem Bedingungs-Ausdruck einen skalaren Datentypen verlangt.

Siehe auch: if

Der Wert des Kontrollausdrucks bestimmt, zu welcher case-Anweisung einer zugehörigen Anweisung gesprungen wird. In fast allen Fällen ist die zugehörige Anweisung eine zusammengefasste Anweisung ({}), welche die verschiedenen case-Anweisungen aufnimmt.

Beispiel:

include 
include 

int main(int argc, char *argv[])
{
 int a=0, b=0;

 switch(argc)
 case 0: puts("Kein Programmname verfügbar.");

 switch(argc)
 {
 case 3: b = atoi (argv[2]);
 case 2: a = atoi (argv[1]);
 printf("%d + %d = %d\
.", a, b, a+b);
 }

 return 0;
}

Im letzten Beispiel werden zwei switch-Anweisungen gezeigt. Die erste switch-Anweisung zeigt, daß geschweifte Klammern nicht zwangsläufig notwendig sind, jedoch wird in einem solchen Fall eher eine if-Anweisung verwendet werden.

Eine case-Anweisung bildet ein mögliches Sprungziel, bei dem die Programmausführung fortgesetzt wird. Die zweite switch-Anweisung im letzten Beispiel definiert zwei case-Anweisungen. Es werden zwei Sprungziele für den Fall definiert, dass argc den Wert 3 bzw. den Wert 2 hat. Der Ausdruck von case muss eine Konstante sein. Dabei darf der Wert des Ausdruck nicht doppelt vorkommen.

switch(var)
{
case 2+3: ;
case 1+4: ; /* illegal */
}

Hat ein case-Ausdruck einen anderen Typen als der Kontrollausdruck, so wird der Wert des case-Ausdruckes in den Typen des Kontrollausdruckes gewandelt.

Wird zu einem der beiden case-Anweisungen gesprungen, so werden auch alle nachfolgenden Anweisungen ausgeführt. Soll die Abarbeitung innerhalb der zugehörigen Anweisung abgebrochen werden, so kann die break-Anweisung eingesetzt werden. So verhindert die break-Anweisung im nachfolgenden Beispiel, dass beide Meldungen ausgegeben werden, wenn kein Parameter beim Programmaufruf angegeben worden sein sollte. Jedoch fehlt eine break-Anweisung zwischen case -1: und case 0:. Dies hat zur Folge, dass in beiden Fällen die Meldung Kein Parameter angegeben ausgegeben wird. Der Ausdruck argc - 1 nimmt den Wert -1 an, wenn auch kein Programmname verfügbar ist.

Beispiel:\

include 

int main (int argc, char *argv[])
{
 switch (argc - 1)
 {
 case -1: case 0: puts("Kein Parameter angegeben");
 break;
 case 1: puts("Ein Parameter angegeben.");
 }
 return 0;
}

Siehe auch: break

Ergibt der Bedingungsausdruck einen Wert, zu dem es keinen entsprechenden Wert in einer case-Anweisung gibt, so wird auch in keinen case-Zweig der zugehörigen Anweisung von switch gesprungen. Für diesen Fall kann eine Anweisung mit der Marke default: benannt werden. Bei der so benannten Anweisung wird die Programmausführung fortgesetzt, wenn kein case-Zweig als Sprungziel gewählt werden konnte. Es darf nur eine default-Marke in einer switch-Anweisung geben.

Siehe auch: Benannte Anweisung

Schleifen

while

Syntax:

while (Ausdruck) Anweisung

Sowohl die while-Anweisung, wie auch deren zugehörige Anweisung (Schleifenkörper) bilden je einen Block.

Beispiel:

include 

int main(int argc, char *argv[])
{
 while(argc>0 && *++argv)
 puts(*argv);

 return 0;
}

Siehe auch: do, for, Block

do

Syntax:

do Anweisung while (Ausdruck);

Sowohl die do-Anweisung, wie auch deren zugehörige Anweisung (Schleifenkörper) bilden je einen Block.

Siehe auch: while, for, Block

Neben der klassischen Rolle einer fußgesteuerten Schleife bietet sich die do-Anweisung an, wenn ein Makro mit mehreren Anweisungen geschrieben werden soll. Dabei soll das Makro der Anforderung genügen, wie eine Anweisung, also wie im folgenden Codefragment verwendet werden zu können.

include 
define makro(sz) do { puts(sz); exit(0); } while(0)

/* ... */
if(bedingung)
	makro("Die Bedingung trifft zu"); 
else
	pust("Die Bedingung trifft nicht zu");
/* ... */

Bei der Definition des Makros fehlt das abschließende Semikolon, dass in der Syntax der do-Anweisung verlangt wird. Dieses Semikolon wird bei der Verwendung des Makros (in der if-Anweisung) angegeben. Die do-Anweisung ist eine Anweisung und da der Kontrollausdruck bei der Auswertung den (konstanten) Wert 0 ergibt, wird der Schleifenkörper (zusammengesetzte Anweisung) genau einmal ausgeführt. Zu diesem Thema äußert sich auch das www2.informatik.uni-wuerzburg.de/dclc-faq/kap6.html#6.3 Kapitel 6.3 der FAQ von dclc.

for

Syntax:

for (Ausdruck-1opt; Ausdruck-2opt; Ausdruck-3opt) Anweisung

for (Ausdruck-1opt; Ausdruck-2opt; Ausdruck-3opt) Anweisung
for (Deklaration Ausdruck-2opt; Ausdruck-3opt) Anweisung

Zu Beginn der for-Anweisung wird der Ausdruck-1 ausgewertet. Der Wert von Ausdruck-2 muss von einem skalaren Datentypen sein und sein Wert wird vor einer eventuellen Ausführung der zugehörigen Anweisung (Schleifenkörper) ausgewertet. Nach einer Ausführung des Schleifenkörpers wird der Ausdruck-3 ausgewertet. Wird der Schleifenkörper nicht ausgeführt, so wird auch nicht der Ausdruck-3 ausgewertet.

Beispiel:

include 

int main(int argc, char *argv[])
{
 int i;

 for(i = 1; i <= 10; i++)
 printf("In der for-Anweisung: i = %2d\
", i);

 printf("Nach der for-Anweisung: i = %d\
\
", i);

 i = 1;
 while( i <= 10)
 {
 printf("In der while-Anweisung: i = %2d\
", i);
 i++;
 }

 printf("Nach der while-Anweisung: i = %d\
", i);

 return 0;
}

Das letzte Beispiel zeigt, wie eine for-Anweisung durch eine while-Anweisung ersetzt werden könnte. Es soll nicht unerwähnt bleiben, dass die beiden Formen nicht dasselbe darstellen. Zum Einen stellt die for-Anweisung eine Anweisung dar, während in dem Beispiel die while-Anweisung von einer Ausdrucksanweisung begleitet wurde. Würden wir beide Anweisungen zusammenfassen, so würden wir einen Block mehr definieren.

Sowohl die for-Anweisung, wie auch deren Schleifenkörper bilden je einen Block.

Auch wenn alle drei Ausdrücke optional sind, so sind es die Semikoli (;) nicht. Die Semikoli müssen alle angegeben werden.

Mit dem Standard C99 ist die Möglichkeit eingeführt worden, eine Deklaration angeben zu können. Dabei ersetzt die Deklaration den Ausdruck-1 und das erste Semikolon. Bei der Angabe der Definition wurde keineswegs die Angabe eines Semikolons zwischen der Deklaration und dem Ausdruck-2 vergessen. In dieser Form ist die Angabe der Deklaration nicht optional, sie muss also angegeben werden. Eine Deklaration wird immer mit einem Semikolon abgeschlossen. Wird diese Form der for-Anweisung verwendet, so ergibt sich das oben fehlende Semikolon durch die Angabe einer Deklaration.

Der Geltungsbereich der mit Deklaration deklarierten Bezeichner umfasst sowohl Ausdruck-2, Ausdruck-3 wie auch Anweisung, dem Schleifenkörper. Selbstverständlich steht der Bezeichner auch innerhalb von Deklaration zur Verfügung, soweit dies nach der Syntax von Deklarationen in C definiert ist.

Beispiel:

include 

int main(int argc, char *argv[])
{
 for(int i = 1; i <= 10; i++)
 {
 int j = 1;
 printf("i = %2d, j = %d\
", i, j);
 j++;
 }

 /* i und j sind hier nicht verfügbar */

 return 0;
}

Siehe auch: while, do, Block

Sprung-Anweisungen

goto

Syntax:

goto Bezeichner ;

Siehe auch: Benannte Anweisung

Bei einem Sprung in den Geltungsbereich eines Bezeichners darf dieser Bezeichner nicht ein Array mit variabler Länge bezeichnen. Entsprechend der Regeln für einen Block werden die Objekte angelegt, jedoch nicht initialisiert worden sein, da die Deklaration übersprungen wurde.

Beispiel:

/* Vorsicht! undefiniertes Verhalten */
include 

int main (void)
{
 goto weiter;
 {
 int i = 99;
 weiter:
 printf("i = %d\
", i); /* i ist nicht initialisiert! */
 }
 return 0;
}

In dem letzten Beispiel ist das Objekt i in der printf-Funktion nicht initialisiert. Daher ist das Verhalten des Programms undefiniert.

Siehe auch: Block

Die Verwendung der goto-Anweisung hat gelegentlich einen, für den Menschen schwer lesbaren Programmcode zur Folge. Wie hoch die Lesbarkeit eines Quelltextes für einen Menschen als Qualitätsmerkmal für ein Programm bewertet wird, dass für einen Rechner geschrieben wurde, ist individuell verschieden. Dennoch soll nicht verschwiegen werden, dass die goto-Anweisung einen schlechten Ruf besitzt und viele Programmierer von ihrer Verwendung abraten. Dieser sollte jedoch nicht dazu führen, dass auf die goto-Anweisung verzichtet wird, obwohl ihre Verwendung eine einfachere Programmstruktur zur Folge gehabt hätte.

continue

continue ;

Hinweis: Die Sprungmarke weiter: ist für die Funktion der continue-Anweisung nicht erforderlich.

 for(int i = 1; i <= 10; i++)
 {
 /* ... */
 continue;
 /* ... */
 weiter: ;
 }

 int i = 1; while(i <= 10)
 {
 /* ... */
 continue;
 /* ... */
 i++;
 weiter: ;
 }

 int i = 1; do
 {
 /* ... */
 continue;
 /* ... */
 i++;
 weiter: ;
 } while (i <= 10);

Das folgende Beispiel gibt eine Folge von Multiplikationen aus. Dabei wird jedoch die Multiplikation ausgelassen, bei der das Ergebnis eine 10 ergeben hat.

Beispiel:

include 

int main (void)
{
 for(int i = 1; i <= 10; i++)
 {
 int erg = 2 * i;

 if( erg == 10) continue;

 printf("2 * %2d = %2d\
", i, erg);
 }

 return 0;
}

Siehe auch: break, Schleifen

break

Syntax:

break ;

Beispiel:

include 

int main (void)
{
 int i;
 for(i = 0; i < 10; i++)
 if ( i == 5)
 break;

 printf("i = %d\
", i);

 return 0;
}

Das Programm in letzten Beispiel gibt eine 5 auf der Standardausgabe aus.

return

Syntax:

return Ausdruckopt ;

Beispiel:

include 
include 

int IsFred(const char *sz)
{
 if(!sz)
 return 0;
 if(!strcmp(sz, "Fred Feuerstein"))
 return 1;
 return 0;
puts("Ich werde nie ausgeführt.");
}

Der Ausdruck in der return-Anweisung ist optional. Dennoch gelten für ihn besondere Regeln. So darf der Ausdruck in Funktionen vom Typ void nicht angegeben werden. Ebenso darf der Ausdruck nur in Funktionen vom Typ void weggelassen werden.

Hat der Ausdruck der return-Anweisung einen anderen Typ als die Funktion, so wird der Wert des Ausdruckes in den Typ gewandelt, den die Funktion hat. Dies geschieht nach den gleichen Regeln, wie bei einer Zuweisung in ein Objekt vom gleichen Typen wie die Funktion.

=Begriffserklärungen=

Die Begriffe in diesem Abschnitt werden im Kapitel 6.8 Statements and blocks in C99 erklärt. Die Erklärung von full expression, die in dem gleichen Kapitel beschrieben ist, soll in Ausdruck (Programmiersprache C)#full_expression erklärt werden.

Anweisung

Gelegentlich ist die Aussage zu lesen, dass in der Sprache C alle Anweisungen mit einem Semikolon abgeschlossen werden. Dies ist nicht richtig. Lediglich die Ausdrucks-Anweisung, die do-Anweisung und die Sprung-Anweisungen werden mit einem Semikolon abgeschlossen. So verwendet folgendes Programm kein Semikolon.

include 

int main (void)
{
 if(printf("Hallo Welt\
")){}
}

Block

Nach 5.2.4.1 Translation limits aus C99 wird eine Verschachtelungstiefe bei Blöcken von mindestens 127 Ebenen garantiert.

Siehe auch: Zusammengesetzte Anweisung, Schleifen, Kapitel 6.2.4 Storage durations of objects (Abs. 5) in C99.

Der Ursprungsartikel stammt von der deutschsprachigen Wiki pedia (siehe oben: "Original Artikel & Autoren Liste"). Der Text steht unter der GNU Freie Dokumentation Lizenz.