#define HALLO "Hallo !"
#define LEERSTRING ""
#define dummy

printf( HALLO );   
/* => printf( "Hallo !" ); */

printf( "dummy" ); 
/* dummy ist eine Zeichenkette, also keine Erweiterung */

printf( "%s", LEERSTRING ); 
/* => printf( "%s", "" ); */

#define HALLO "Hallo !"
#define AUSGABE printf( HALLO );
#define STDIO #include <stdio.h>

AUSGABE 
/* => printf( "Hallo !" ); */

STDIO 
/* => #include <stdio.h> wird an den Compiler weitergegeben ! */

Die Argumentliste ist eine Folge von Bezeichnern, die durch Kommata voneinander getrennt werden und Ähnlichkeit mit der Argumentliste einer C-Funktion haben. Jedes Argument in dieser Liste spielt die Rolle eines formalen Arguments. Auf diese Art definierte Makros werden auf folgende Weise im Quelltext aufgerufen :

Die Syntax ist rein äußerlich identisch mit der des Aufrufs einer C-Funktion. Die Anzahl der Argumente muß mit der Anzahl der Parameter in der #define-Direktive übereinstimmen, ansonsten wird eine Fehlermeldung generiert. Ein solcher Makroaufruf erwirkt eine doppelte Ersetzung. Zuerst werden der Makrobezeichner und die Argumente durch die Symbolsequenz ersetzt. Danach werden alle formalen Argumente innerhalb der Symbolsequenz durch ihre tatsächlichen Argumente aus dem Aufruf ersetzt. Hierzu ein Beispiel :

#define MUL(a,b) ((a)*(b))
wert = MUL( 5, 10 ); /* wert = ((5)*(10)); */

#define MUL( a,b ) a*b
wert = MUL( 2+3, 5+5 );

wert = 2+3*5+5;

Bei der Verwendung von Makros mit Parametern sollten folgende Punkte beachtet werden :

Die Bedingungsdirektiven #if, #ifdef und #ifndef funktionieren wie normale Bedingungsoperatoren in C. Sie werden folgendermaßen verwendet :

Die abgearbeitete Sektion kann weitere Bedingungsblöcke in beliebiger Tiefe enthalten.

Der defined-Operator bietet eine flexible Alternative für die Überprüfung, ob Kombinationen von Bezeichnern definiert sind oder nicht. Dieser Operator ist nur innerhalb von #if- und #elif-Ausdrücken zulässig. Der Vorteil ist, daß man defined in komplexen Ausdrücken verwenden kann :

#if defined(__STDC__) || defined(__DCC32__)
...
#endif

- #pragma symused sym [sym ...]
Diese Direktive unterbindet die Compiler-Warnung "<sym> ist überflüssig", indem die Benutzung der angegebenen Symbole simuliert wird. Bei unbekannten Symbolen wird die Direktive ignoriert. Als Symbole können die Namen aller deklarierten Funktionen und Variablen (auch Funktionsparameter) benutzt werden, aber keine Präprozessor-Makros.

- #pragma warn N
Durch '#pragma warn' kann die Ausgabe von Warnmeldungen durch den Compiler für bestimmte Programmabschnitte ein- oder ausgeschaltet werden. Bei N=1 werden alle Warnungen angezeigt, bei N=0 unterdrückt. Diese Direktive hat Vorrang vor der Kommandozeilen-Option -w.

Dezimalkonstanten
Dezimalkonstanten reichen von 0 bis 4294967295. Konstanten außerhalb dieses Bereiches erzeugen eine Warnmeldung und werden entsprechend abgeschnitten. Dezimalkonstanten dürfen nicht mit einer 0 beginnen, ansonsten werden sie als Oktalkonstanten interpretiert.

int a=100;  /* dezimal 100 */
int b=0100; /* Achtung : dezimal 64 = oktal 100 */
int c=0;    /* dezimal 0 = oktal 0 */

Hexadezimalkonstanten
Alle Konstanten, die mit 0x oder 0X beginnen, werden als Hexadezimalkonstanten interpretiert. Der Wertebereich geht von 0 bis 0xFFFFFFFF. Größere Werte erzeugen eine Warnmeldung und werden entsprechend abgeschnitten.

int a = 0x100;   /* hexadezimal 100 */
int b = 0X10000; /* hexadezimal 10000 */

Oktalkonstanten
Alle Konstanten, die mit einer Null(= '0', aber nicht '0x'/'0X' !) beginnen, werden als Oktalkonstanten interpretiert. Der Wertebereich reicht von 0 bis 037777777777. Konstanten außerhalb dieses Bereiches erzeugen eine Warnmeldung und werden entsprechend abgeschnitten.

int a = 0500; /* oktal 500 */
int b = 001;  /* oktal 1 */

Suffixe
Beinhaltet eine der oben aufgeführten Konstanten den Suffix 'l' oder 'L', wird die Konstante als long dargestellt. Durch den Suffix 'u' oder 'U' wird eine Kostante als unsigned (vorzeichenlos) dargestellt. In der folgenden Tabelle ist aufgelistet, welche Konstanten welchem Typ entsprechen, wobei davon ausgegangen wird, daß die Konstanten ohne Suffix benutzt wurden :

Typ	Bereich
int	0 bis 2147483647
	0x0 bis 0x7FFFFFFF
	00 bis 017777777777
unsigned int	2147483648 bis 4294967295
	0x80000000 bis 0xFFFFFFFF
	020000000000 bis 037777777777

Da DCC32 ein reiner 32Bit-Compiler ist, besteht prinzipiell kein Unterschied zwischen einem int- und einem long-Datentyp. Der Suffix 'l' bzw. 'L' ist somit unbedeutend. Das gleiche gilt für unsigned int und unsigned long, wo die Suffix-Kombinationen 'UL' bzw. 'ul' gleichbedeutend sind mit 'U' bzw. 'u'.

 
1. Vorkommastellen
2. Dezimalpunkt
3. Nachkommastellen
4. e oder E und ein vorzeichenbehafteter, ganzzahliger Exponent (optional)
5. f oder F, bzw. l oder L als Suffix

• Vorkomma- oder Nachkommastellen, aber nicht beide gleichzeitig
• Dezimalpunkt oder e (oder E) und der Exponent (nicht beides gleichzeitig)

Konstante	Wert
1012.	1012
18E5	18 x 105 = 1800000
10.	10 x 100
.1	1 x 10-1 = 0.1
.012e3	0.012 x 103 = 12
12.1712	12.1712
17e-5	17.0 x 10-5 = 0.00017

Gleitkommakonstanten ohne Suffix sind vom Typ double. Durch den Suffix 'f' oder 'F' kann einer Gleitkommakonstanten der Typ float und durch 'l' oder 'L' der Typ long double zugewiesen werden.

char-Typen
Konstanten, die aus einem einzigen Zeichen bestehen (z.B. 'A', 'b' oder '\0'), werden als int-Datentyp dargestellt. In diesem Fall gilt das niederwertigste Byte als vorzeichenbehaftet, was bedeutet, daß die drei höherwertigen Bytes den Wert -1 (0xFF) enthalten, wenn der Wert des Zeichens größer ist als 127. Ist der Wert des Zeichens kleiner oder gleich 127, enthalten die drei höherwertigen Bytes den Wert 0 (0x00). Dies kommt dadurch, daß der Datentyp char identisch ist mit signed char, wodurch die Werte aller Zeichen grundsätzlich vorzeichenbehaftet dargestellt werden. Bei der Übertragung eines Zeichens in ein int-Datenfeld muß daher auch das Vorzeichen auf das int-Datenfeld übertragen werden (diesen Vorgang nennt man Vorzeichenerweiterung, bzw. "sign-extension").

Escape-Sequenzen
Mit dem Backslash (\) werden Escape-Sequenzen begonnen, die zur Repräsentation nicht darstellbarer Zeichen dienen :

Sequenz	Wert	Bedeutung
\a	0x07	Alarmton
\b	0x08	Backspace
\f	0x0C	Seitenvorschub (form feed)
\n	0x0A	Zeilenvorschub (line feed)
\r	0x0D	Wagenrücklauf (carriage return)
\t	0x09	horizontaler Tabulator
\v	0x0B	vertikaler Tabulator
\\	0x5C	Backslash
\'	0x27	Apostroph
\"	0x22	Anführungszeichen
\?	0x3F	Fragezeichen
\O	...	O = String mit max. 3 Oktalziffern
\xH	...	H = String mit Hexziffern
\XH	...	H = String mit Hexziffern

• Stringkonstanten :

"Ich bin eine Stringkonstante !"

"Dies ist der Alarmton : \a und dies der Zeilenvorschub : \n"

printf( "Teil1 " "Teil2 " "Teil3" );

Teil1 Teil2 Teil3

printf( "Dieser lange Text \
wurde auf vier Textzeilen verteilt, \
obwohl er in Wirklichkeit einen \
einzeiligen Text darstellt." );

• Aufzählungskonstanten :

enum geraete { fernseher, cdplayer, receiver};

fernseher = 0, cdplayer = 1, receiver = 2

enum geraete { fernseher,cdplayer=2,receiver,rekorder=cdplayer-2 };

fernseher = 0, cdplayer = 2, receiver = 3, rekorder = 0

Es folgt eine Aufstellung aller Datentypen mit Platzbedarf und Wertebereichen :

Datentyp	Größe (Bits)	Wertebereich
char	8	-128 bis 127
unsigned char	8	0 bis 255
short int	16	-32768 bis 32767
unsigned short int	16	0 bis 65535
int	32	-2147483648 bis 2147483647
unsigned int	32	0 bis 4294967295
long	32	-2147483648 bis 2147483647
unsigned long	32	0 bis 4294967295
float	32	3.4 x 10-38 bis 3.x 1038
double	64	1.7 x 10-308 bis 1.7 x 10308
long double	80	3.4 x 10-4932 bis 1.1 x 104932

3.5.6 Interpunktionszeichen

•  Runde Klammern ( ) isolieren konditionale Ausdrücke, fassen Ausdrücke zusammen und repräsentieren Funktionsaufrufe und -parameter :

getch();
if (*p) printf( "a" );
m = 500 * ( a + ( 200 / d ));
double (*funktion) ( void );

• Geschweifte Klammern { } markieren den Beginn und das Ende eines Anweisungsblocks :

if (m==80)
{
  m++;
  printf ("%d\n", m);
}

Die abschließende Klammer ( } ) dient als Endemarkierung für den Anweisungsblock, der daher kein Semikolon folgen darf (eine Ausnahme bilden Strukturdeklarationen und Initialisierungen von Arrays).

• Eckige Klammern [ ] beinhalten ein- oder mehrdimensionale Arrayindizes :

char arr[] = "Beispiel";
double vp[4][10];
vp[2][1] = 100.2;

• Das Semikolon ( ; ) dient zur Beendigung einer Anweisung. Jeder gültige Ausdruck, an dessen Ende ein Semikolon steht, wird als Anweisung betrachtet (in diesem Fall wird der Ausdruck zwar ausgewertet, doch sein Ergebnis wird verworfen) :

m * 3; /* Audruck wird ausgewertet, aber Ergebnis wird verworfen */
; /* ergibt einen leeren Ausdruck => leere Anweisung */
C++; /* C wird um 1 erhöht, der alte Wert von C wird verworfen */

Semikolons werden außerdem häufig in Schleifen zur absichtlichen Darstellung von leeren Anweisungen benutzt :

while (*s1++ = *s2++ )
  ;

• Das Komma ( , ) dient zur Trennung der Elemente einer Funktions-Argumentliste :

void test ( int, char, char *, char [] );

Es wird auch als Operator in Komma-Ausdrücken benutzt. Die Kombination beider Komma-Anwendungen ist erlaubt, solange runde Klammern zur Unterscheidung benutzt werden :

/* Aufruf von fprintf mit 3(!) Argumenten : */
fprintf (stdout, fehler, (p1, p2, p3, p4 ));

• Der Stern ( * ) in einer Deklaration zeigt an, daß ein Zeiger auf den Typ definiert wurde :

char *charzeiger; /* = Zeiger auf ein char-Datenfeld */
int *iptr; /* = Zeiger auf ein int-Datenfeld */

Zeiger mit mehrfachen Indirektionsebenen werden durch entsprechend viele Sternchen gekennzeichnet :

char **charzeiger; /* = Zeiger auf Array aus char-Zeigern */
int ***iptr; /* = Zeiger auf ein 2-dim. Array aus int-Zeigern */

Das Sternchen kann auch als Operator, der einen Zeiger dereferenziert oder als Multiplikations-Operator eingesetzt werden :

int val = *iptr; /* val = Datenfeld, auf das iptr zeigt */
val = val * 4; /* val multipliziert mit 4 */

• Der Doppelpunkt ( : ) kennzeichnet ein Label :

marker:
  v=0;
  ...
  goto marker;

Sprungziele in switch-Anweisungen werden ebenfalls durch den Doppelpunkt gekennzeichnet :

switch (val)
{
  case 100 : printf ("100 !\n"); break;
  case 200 : printf ("200 !\n"); break;
  case 300 : printf ("300 !\n"); break;
  default  : printf ("Falscher Wert !\n");
}

• Die Ellipse ( ... ) besteht aus drei aufeinanderfolgenden Punkten ohne Whitespaces dazwischen. Sie dient zur Kennzeichnung einer variablen Anzahl von Argumenten oder von Argumenten mit nicht festgelegtem Typ in der Argumentliste einer Funktion :

int fprintf (FILE *stream, const char *format, ... );

Der Funktionsprototyp von fprintf besagt, daß jeder Aufruf mindestens zwei Argumente (stream und format) erfordert. Dahinter können beliebig viele Argumente mit beliebigen Typen folgen.

• Das Gleichheitszeichen ( = ) dient als Zuweisungsoperator in Ausdrücken :

k = m * 10 + a;
double *m = &f;

Außerdem dient das Gleichheitszeichen zur Trennung zwischen Variablendeklarationen und Initialisierungslisten :

int arr[5] = { 0, 1, 2, 3, 4 };

Jede Deklaration benötigt einen Speicherklassenspezifizierer. Folgende Spezifizierer stehen dazu zur Verfügung:

• auto

• extern

• register

• static

• typedef

typedef unsigned char UCHAR;
UCHAR c; /* ist identisch mit 'unsigned char c;' */

Neben den Schlüsselwörtern zur Festlegung der Speicherklasse können in einer Deklaration Modifizierer eingesetzt werden, die die zum Bezeichner gehörende Speicherbelegung beeinflussen :

• const

const val = 1; /* => const int val = 1; */
const double pi = 3.14159265359;
/* Zeiger s ist nicht veränderbar : */
char * const s = "Ich bin veränderbarer Text";
/* String ist nicht veränderbar : */
const char *t = "Ich bin ein unveränderbarer Text";
/* String und Zeiger u sind nicht veränderbar : */
const char * const u = "u und ich sind unveränderbar";

val = 3;            /* Meldung : Zuweisung an "const"-Bezeichner "val" */
s = "Wie geht's ?"; /* Meldung : Zuweisung an "const"-Bezeichner "s" */
t[0] = 'R'; 	    /* Meldung : Zuweisung an "const"-Bereich */
u++;        	    /* Meldung : Zuweisung an "const"-Bezeichner "u" */
u[2]='U';   	    /* Meldung : Zuweisung an "const"-Bereich */

s[0]='R'; /* s wird hierdurch nicht verändert */
strcpy( s, "Neuer Text" ); /* hier wird s auch nicht verändert */
t = "Hallo !"; /* der ursprüngliche String bleibt unverändert */

char *v = s; /* nicht erlaubt, wegen "char * const s = ..." */

• volatile

volatile int counter;

void timerhandler( void )
{
  counter++;
  OriginalHandler( 8 );
}

int main( int argc, char *argv[] )
{
  RegisterHandler( 8, timerhandler );

  for (;;) {
    printf( "%d\n", counter );
  }

  return 0;
}

Es gibt zwei Kategorien von Zeigern : Zeiger auf Objekte und Zeiger auf Funktionen. Beide Typen sind spezielle Objekte, die Speicheradressen enthalten. Da jede Adresse 32 Bits breit ist, benötigt jeder Zeiger immer 4 Bytes Speicher. Generell kann gesagt werden, daß Zeiger auf Funktionen für den Zugriff auf Funktionen und für die Übergabe von Funktionen als Argumente an andere Funktionen verwendet werden. Berechnungen mit Zeigern auf Funktionen sind generell unzulässig. Zeiger auf Objekte hingegen können inkrementiert und dekrementiert werden, wenn Arrays oder Datenstrukturen im Speicher abgesucht werden. Obwohl Zeiger im Prinzip Zahlen beinhalten, die praktisch dieselben Eigenschaften haben wie vorzeichenlose Integervariablen, gelten einige besondere Regeln im Umgang mit Zeigern.

• Zeiger auf Objekte :

char *text = "Ganz normaler Text";
double **gehaelter;

• Zeiger auf Funktionen :

int (*funk)( void );
char * (*funk2) ( char *, int );

/* Array mit 5 Integerwerten / Index von 0 bis 4 : */
int i_arr[]={0, 1, 2, 3, 4 };
int *iptr; /* Zeiger auf ein Integerobjekt */
iptr = i_arr; /* iptr zeigt auf das erste Element von i_arr */

/* Ausgabe des Wertes, auf den iptr zeigt (= i_arr[0]) : */
printf( "*iptr = %d\n", *iptr );

/* iptr auf nächstes Element in Array setzen : */
iptr++;

/* Ausgabe des Wertes, auf den iptr zeigt (= i_arr[1]) : */
printf( "*iptr = %d\n", *iptr );

/* Ausgabe des nachfolgenden Wertes (= i_arr[2]) : */
printf( "iptr[1] = %d\n", iptr[1] );

char *str;
int *i;
i = (int*)str;

char *str;
int *i;
i = str; /* Fehler : Unzulässige Typen "int*" und "char*" */

Ein Array kann auf folgende Art definiert werden :

int array[10];

int array[10] = { 0, 1, 2, 3, 4, 5 };

int array[10][5];

/* 8 Elemente à 1 Byte mit abschließendem '\0' : */
char string[] = "Hallo !";
int array[] = { 0, 1, 2, 3, 4 }; /* 5 Elemente à 4 Bytes */

char string[100] = "Hallo !";
strcpy( string, "Neuer Text !" );

3.5.11. Funktionen

Funktionen sind die zentralen Bestandteile eines C-Programms. Während andere Sprachen (z.B. Pascal) eine Unterscheidung zwischen Prozeduren (keine Rückgabewerte) und Funktionen (Rückgabewerte) machen, übernehmen Funktionen in C beide Aufgaben.

Jedes C-Programm muß zumindest aus der main-Funktion bestehen, die beim Programmstart durch das Startmodul aufgerufen wird und den Einstiegspunkt für die Ausführung eines C-Programms darstellt. Vor der Benutzung einer Funktion muß diese durch einen Prototyp im voraus deklariert werden, damit der Compiler später die Gültigkeit der Aufrufe überprüfen und gegebenenfalls automatische Typkonvertierungen vornehmen kann. Funktionen können beliebig oft in Form eines Prototyps deklariert werden, solange die Prototypen identisch sind. Eine Deklaration sieht folgendermaßen aus :

[ typ ] funk ( );

[ typ ] funk ( Deklaratorenliste );

extern int irgendwas (double);

int main ( int argc, char *argv[] )
{
  int k;
  k = irgendwas( 1 );
  return 0;
}

Für Dokumentationszwecke ist es auch möglich, in einem Funktionsprototypen die Namen für die Argumente zu nennen. Ein Beispiel ist die Funktion memmove, die drei Argumente erwartet :

void *memmove( void *ziel, const void *quelle, size_t anzahl );

funktion( void );

3.5.12 Strukturen

Eine Struktur ist ein Typ, der für eine vom Benutzer definierte Ansammlung von benannten Elementen (oder Komponenten) besteht. Diese Elemente können jeden standardmäßigen und selbstdefinierten Typ in beliebiger Reihenfolge aufnehmen. Außerdem kann in einer Struktur ein Bitfeld verwendet werden, was sonst nicht zulässig ist. Strukturen werden mit dem Schlüsselwort struct definiert :

struct memnode {
  unsigned groesse;
  void *naechster_block;
};

struct {
  unsigned groesse;
  void *naechster_block;
} p, m[10], *f;

typedef struct { 
  unsigned groesse; 
  void *naechster_block; 
} MEMNODE;
MEMNODE p;
MEMNODE m[10], *f;

struct memnode {
  unsigned groesse;
  void *naechster_block;
  struct memnode irgendwas; /* Fehler : Undefinierte Feldgröße */
};

struct memnode {
  unsigned groesse;
  void *naechster_block;
  struct memnode *irgenwohin; /* ist erlaubt, da Zeiger => 4 Bytes */
};

Zugriffsoperatoren

Auf Struktur- und Variantenelemente kann über diese beiden Auswahloperatoren zugegriffen werden :

• . (Punkt)
• -> (Pfeil nach rechts)

struct irgendwas {
  int k;
  char name[32];
  double v;
} a, *b;

b=&a;
a.k = 100;
b->v = 1.0;
strcpy( b->name, "Hallo" );
printf( "%s\n", a.name );

Speichernutzung

Speicher wird einer Struktur elementweise von links nach rechts zugewiesen :

struct irgendwas {
  char name[32];
  int t;
  double v;
  float c;
} k;

Bitfelder

Es können "signed int" und "unsigned int" Integerelemente als Bitfelder in einer Struktur mit einer Größe von 1 bis 32 definiert werden. Die Größe und optionalen Bezeichner des Bitfelds werden wie folgt angegeben :

Typ [ Bezeichner ] : Größe

Integer-Bitfelder werden immer in 2er-Komplementform angelegt, wobei das linke Bit das höchstwertige Bit darstellt. Bei vorzeichenbehafteten Datentypen dient dieses Bit als Vorzeichen.
 

3.5.13 Varianten (Unions)

Die Variante ist ein Typ, die in vielen Punkten einer Struktur ähnelt. Der Hauptunterschied ist der, daß in einer Variante immer nur eines der deklarierten Elemente aktiv ist. Die Größe einer Variante wird durch ihr größtes Element bestimmt (und nicht von der Summe aller Elemente wie bei einer Struktur) :

union irgendwas {
  double v;
  int k;
  char t[6];
  float c;
} was, *wo, wie[10];

Hier ein Beispiel, das die obige Variante benutzt :

wo = &was;

/* 100 in das Integerelement k bringen : */
was.k = 100;

/* gibt 100 als Integer aus : */
printf( "%d\n", wo->k );

/* ergibt unvorhersagbares Laufzeitverhalten : */
printf( "%f\n", was.v); 

3.5.14. Ausdrücke und Operatoren

Die Auswertung von Ausdrücken richtet sich nach bestimmten Konvertierungsregeln, der Abarbeitungsreihenfolge, der Richtung der Operatoren, dem Vorhandensein von Klammern und den Datentypen der Operatoren.

In der folgenden Tabelle ist zunächst die Reihenfolge der C-Operatoren aufgelistet. Ganz oben steht der Operator mit der höchsten und am Ende der mit der niedrigsten Prioritätsstufe :

Stufe	Operator	Funktion	Abarbeitungsrichtung
16	->, .	Auswahloperatoren	links nach rechts
16	[ ]	Array-Index	links nach rechts
16	( )	Funktionsaufruf	links nach rechts
16	( )	Typkonstruktion	links nach rechts
15	++, --	Inkrement, Dekrement	rechts nach links
15	~	bitweises NOT	rechts nach links
15	!	logisches NOT	rechts nach links
15	+, -	unäres Plus / Minus	rechts nach links
15	*, &	Dereferenzierung / Adressoperator	rechts nach links
15	( )	Typvorgabe (Cast)	rechts nach links
14	->*, .*	Auswahloperatoren für Zeiger	links nach rechts
13	*,/,%	multiplikative Operatoren	links nach rechts
12	+, -	Addition und Subtraktion	links nach rechts
11	<<, >>	Bitverschiebung	links nach rechts
10	<, <=,=>, >	relationale Operatoren	links nach rechts
9	==, !=	Gleichheit, Ungleichheit	links nach rechts
8	&	bitweises AND	links nach rechts
7	^	bitweises XOR	links nach rechts
6	|	bitweises OR	links nach rechts
5	&&	logisches AND	links nach rechts
4	||	logisches OR	links nach rechts
3	? :	arithmetischer if-Operator	links nach rechts
2	=, *=, /=, &=, +=, -=, <<=, >>=, &=, |=,=	Zuweisungsoperatoren	rechts nach links
1	,	Komma-Operator	links nach rechts

Hier ein Beispiel für eine auf den ersten Blick korrekte, auf den zweiten jedoch falsche Anweisung :

while ( z=getch() != 'A' )
  ;

while ( (z=getch() ) != 'A' )
  ;

3.5.15 Anweisungen

Anweisungen steuern den Ablauf während der Ausführung eines Programms. Enthält das Programm keine Sprung- und Auswahlanweisungen, dann werden die Anweisungen sequentiell bis zur letzten Anweisungen durchgearbeitet.

• Label / Marken

• Auswahlanweisungen

int c;
c=getch();
switch ( c ) {
  case 'a' : printf( "\'a\' wurde gedrückt !\n" ); break;
  case 'b' : printf( "\'b\' wurde gedrückt !\n" ); break;
  case 'c' :
  case 'd' : printf( "\'c\' oder \'d\' wurde gedrückt !\n" ); break;
  default : printf( "\'%c\' wurde gedrückt !\n", c );
}

• Wiederholungsanweisungen

1. Der Initialisierungsausdruck wird (wenn vorhanden) ausgeführt. Dadurch werden meist ein oder mehrere Schleifenzähler initialisiert.
2. Nun wird der Testausdruck ausgewertet. Ergibt er den Wert Null (falsch), wird die for-Anweisung beendet und die darauf folgende Anweisung ausgeführt.
3. Ergibt er jedoch einen Wert ungleich Null (wahr), wird die Anweisung ausgeführt, was auch der Fall ist, wenn der Testausdruck nicht vorhanden ist.
4. Jetzt folgt die Auswertung des Inkrementierungsausdrucks, durch den meist die Schleifenzähler verändert werden. Danach geht die Bearbeitung wieder zu Schritt 2 zurück.

Diese Anwendung der for-Anweisung erzeugt eine Endlosschleife :

for (;;) ;

while-Anweisung

Das Format der while-Anweisung sieht so aus :



while (Bedigungsausdruck) Anweisung


Die Anweisung wird solange ausgeführt, wie der Bedingungsausdruck einen Wert ungleich Null (wahr) ergibt. Der Bedingungsausdruck wird dabei vor jeder Ausführung der Anweisung ausgewertet. Ergibt dieser den Wert wahr, wird die Anweisung ausgeführt, ansonsten wird zur darauf folgenden Anweisung verzweigt. Gibt es keine Sprungbefehle, muß die Anweisung auf den Wert von Bedingungsausdruck Einfluß nehmen, oder der Bedingungsausdruck muß sich selbst beeinflussen, ansonsten erhält man eine Endlosschleife.

do...while-Anweisung

Das Format lautet wie folgt :



do Anweisung while (Bedingungsausdruck);

Die Anweisung wird solange ausgeführt, wie der Bedingungsausdruck einen Wert ungleich Null (wahr) ergibt. Der Unterschied zur while-Anweisung besteht darin, daß der Bedingungsausdruck nach der Ausführung der Anweisung ausgewertet wird. Die Anweisung wird also mindestens einmal ausgeführt. Ansonsten gelten die gleichen Regeln wie bei der while-Anweisung.

• Sprunganweisungen

strncmp( s1, s2, len );

push len
push s2
push s1
call _strncmp
add esp,12

push len
push s2
push s1
call strncmp

Bei der Deklaration bzw. Definition von Funktionen wird die verwendete Aufrufkonvention zwischen Typ und Funktionsnamen angegeben, z.B. so:

/* func ist eine __cdecl-Funktion : */
int __cdecl func( );

/* test ist eine __stdcall-Funktion : */
char * __stdcall test( int, char * );

/* test2 ist eine __cdecl-Funktion : */
void __cdecl test2( const char *s, FILE *f )
{
  printf( s, f );
}

/* ptr: Zeiger auf _stdcall-Funktion des Typs int ohne Argumente : */
extern int __cdecl (*ptr)( void );

/* ptr2: Array mit Zeigern auf __stdcall-Funktionen des Typs int 
   mit 2 Argumenten : */
__stdcall (*ptr2[10])( char *, int );

int __cdecl func( );

int func( );