Die Programmiersprache C:

C unterscheidet Gro- und Kleinschreibung, d.h. Standartbefehle und Schlsselwrter sind stets klein geschrieben

1. Der Kommentar: 2. Die Standartdateien:

/* Dies ist ein Kommentar */ # include <stdio.h> # include <math.h> # include <conio.h>

3. Das Hauptprogramm:
main ( ) dies ist das Hauptprogramm und fester Bestandteil jedes Programms in C { 1. Schritt innerhalb jeden Programms ist die Definierung der verwendeten Variablen int Zahla, Zahlb; float Parameter1; getch ( ); return 0; Abschlu eines Programms

} Daneben knnen beliebig viele Unterprogramme nach folgenden Muster enthalten sein: Funktionsname (Variable1, Variable2, Variable3,...) 4.

Anweisungen:

(mssen mit einem Strichpunkt abgeschlossen sein)

a) Variablentypen: int long int short int unsigned int unsigned short int unsigned long int char unsigned char float double %c %s %f %le %e %E %g %x %X %o %u %% b) mathematische Ausdrcke: + % Addition Subtraktion Modulo (berechnet den Rest einer Operation) * / Multiplikation Division %d %ld %u [Integer] Ganzzahlige Zahlen - 32 768 ... 32 767 - 2 147 483 648 ... 2 147 483 647 - 2 147 483 648 ... 2 147 483 647 - 32 768 ... 32 767 0 ... 65 535 0 ... 4 294 967 295 0 ... 65 535 0 ... 4 294 967 295 (16 Bit) (32 Bit) (16 Bit) (32 Bit)

[Charakter] ein Zeichen bzw. alle ASCII-Zeichen alle ASCII-Zeichen Zeichenkette char* , bzw. char [] [Floating Piont] Fliekommazahlen - 10^38 ... 10^38 Fliekommazahlen mit doppelten Wertebereich - 10^308 ... 10^308 Fliekommazahl in Exponentialschreibweise (23e+432) wie %e nur mit groen E (23E+432) Exponential- oder Fliekommaschreibweise, in Abhngigkeit vom Wert Hexadezimal mit kleinem a...f Hexadezimal mit groem A...F Oktalzeichen wie %d, aber nur Werte ohne Vorzeichen gibt ein % am Bildschirm aus

c) Sonderzeichen: \n \t \b \r Zeilenvorschub, entspricht RETURN Tabulator, auf den Bildschirm wird ein Tabulatur-Sprung gemacht Backspace, letztes Zeichen wird gelscht Carriage Return. Unter DOS besteht ein Zeilenende aus \n\r

\f \0 \\ \` \ d) printf: z.B. e) scanf: z.B. f) getchar:

bewirkt bei der Druckerausgabe einen Seitenvorschub NULL, wird intern fr String-Endmarkierungen verwendet Backlash, erzeugt ein \ auf dem Bildschirm Erzeugt ein Hochkomma auf dem Bildschirm Erzeugt Anfhrungszeichen auf dem Bildschirm gibt einen Text auf den Bildschirm wieder. printf(Dies ist ein Text); printf(Das Zeichen %c ist im ASCII-Code ein %d ,Zeichen, Zeichen); liet eine Variable vom Bildschirm ein. scanf(%d, &Zahl);

getchar liefert einen char-Wert zurck z.B. char getchar ();

g) putchar: gibt einen char -Zeichen aus z.B. char putchar (`a); h) clrscr (); lscht den Bildschirm

5. Bitmanipulation:
Aufruf: ~ Zahl :

# include <zeig_bin.h> zeig_binaer (Zahl1); => z.B. 0000 1111 1111 0000 0000 1111 & 0001 0110 = 0000 0110 0000 1111 | 0001 0110 = 0001 1111 0000 1111 ^ 0001 0110 = 0001 1001 0000 1111 0011 1100

es erfolgt eine bitweise Negation

Zahla & Zahlb beide Zahlen werden bitweise mit und verknpft

Zahla | Zahlb

beide Zahlen werden bitweise mit oder verknpft

z.B.

Zahla ^ Zahlb beide Zahlen werden bitweise exklusiv verodert

z.B.

Zahl << X Zahl >> X

Die Bits der Zahl werden um X Stellen nach links verschoben Die Bits der Zahl werden um X Stellen nach rechts verschoben

<< 2 : =>

>> 2 : 0000 1111 => 0000 0011

6. Typenumwandlung (Casting):
( Zieltyp ) Variable int Zahl =4; d = ( double ) Zahl == != > >= < <= && || ! z.B. ( die Variable Zahl ist hier eine ganze Zahl ) ( die Variable Zahl ist hier eine Fliekommazahl)

7. Vergleichsoperation:
gleich ; beide Ausdrcke sind gleich ungleich ; beide Ausdrcke sind nicht gleich grer ; der erste Ausdruck ist grer als der zweite grer gleich ; der erste Ausdruck ist grer oder gleich dem zweiten kleiner ; der erste Ausdruck ist kleiner als der zweite kleiner gleich ; der erste Ausdruck ist kleiner oder gleich dem zweiten logisches und ; beide Ausdrcke mssen wahr sein logisches oder ; einer der Ausdrcke mu wahr sein Negation ; der folgende Ausdruck mu falsch sein

8. Schleifen:
Es gibt zwei unterschiedliche Arten von Schleifen: vor- und nachprfende Schleifen while : while (Bedingung) { Schleifenkrper Anweisung } do { Schleifenkrper while (Bedingung);

do ... while :

for :

for (Initialisierung; Bedingung; Anweisung) z.B. for ( i=0 ; i<10 ; i=i+1 ) { Schleifenkrper }

continue : break : if :

Schleife wird unterbrochen und direkt zum Vergleich gesprungen Schleife wird unterbrochen und direkt zum nchsten Befehl nach der Schleife gesprungen if ( Bedingung ) { Zweig 1 } else { Zweig 2 } Bedingung wahr, dann Zweig 1 Bedingung falsch, dann Zweig 2 z.B. if ( t==1 ) printf (Eins) ; else if ( t==2 ) printf (Zwei) ; else if ( t==3) : else printf (keine Ahnung); z.B. Aktion 1 ; break; Aktion 2 ; break; Aktion 3 ; break; Aktion 4 ; switch ( t ) { case 1 : printf (Eins); break; case 2 : printf (Zwei); break; case 3 : printf (Drei); break; default: printf (keine Ahnung); }

if & else if :

if ( Bedingung 1 ) { Zweig 1 } else if ( Bedingung 2 ) { Zweig 2 } else if ( Bedingung 3 ) : else { Zweig 3 }

switch & case : switch (Variable) { case Term 1: case Term 2: case Term 3: default: }

9. Unterprogramme / Funktionen:
Unterprogramme dienen dazu, mehrmals benutzte Programmsequenzen zu einer Sequenz zusammenzufassen Die so entstehenden Unterprogramme stehen auch fr zuknftige Programme zu Verfgung (Modularisierung) Die Programme werden krzer und bersichtlicher geringere Fehleranflligkeit scanf (...) printf (...) pow (...) zum Einlesen von Werten zur Ausgabe von Werten zur Berechnung von Potenzen

Beispiele:

Allgemeiner Aufbau ein Unterprogramms bzw. einer Funktion: Typ des Rckgabewertes Funktionsname ( formaler Parameter 1, formaler Parameter 2, ...) { Funktionsrumpf Rckgabewert Return...; } z.B. : /* Funktion zum Vertauschen von zwei ganzen Zahlen */ void swap (int* a, int* b) { int dummy; Festlegung der Variablen innerhalb des Unterprogramms

} int main(void) { int x=2, y =3 ; swap(&x, &y); return 0; }

dummy = *a ; *a = *b ; *b = dummy ; return ;

Vertauschung der Zahlen mit Hilfe einer Hilfsvariablen

Hauptprogramm Festlegung der Variablen Aufruf des Unterprogramms

Will man den Wert eines formalen Parameters in einer Funktion ndern, so braucht man stets eine entsprechende Zeigervariable. Denn sonst merkt das aufrufende Programm von einer Wertnderung in der Funktion nichts. Eine Funktion braucht nicht zwingend einen formalen Parameter: int holeZufallszahl(void) bzw. int holeZufallszahl()

10. Felder :
eindimensionales Feld :

Feldtyp

Feldname [Feldgre]; int vektor[10]; vektor[0] ... vektor[9]

erzeugt ein Feld von 10 Elementen des Typs Integer.

Die einzelnen Elemente sind: zweidimensionales Feld : Zugriff auf ein einzelnes Element: Feldinitialisierung : bzw. : bzw. :

int matrix[4][5]; matrix [0][0] ... matrix [3][4]

int feld[7] = {1,2,3,4,5,6,7}; int feld[3][3] = { int feld[][3] = { {1,2,3}, {1,2,3}, {4,5,6}, {4,5,6}, {7,8,9} {7,8,9} }; };

Initialisierung von Zeichenfeldern : char samstag[ ] = Samstag; Beispiel:

m a in () { in t fe ld [ 5][ 5] = { { 0, 0 , 0, 0, { 0 , 0, 0 , 0, { 0 , 0, 0 , 0, { 0 , 0, 0 , 0, { 0 , 0, 0 , 0, }; feld [ 2 ][ 1] = 1; feld [ 3][ 1] = 2 ; feld [ 2 ][ 2 ] = 5; in t x, y ; fo r ( x = 0; x <5; x ++ ) { fo r ( y = 0; y <5; y ++ ) { p rin t ("% d ", fe ld [ x ][ y ]) ; } p rin tf } } ("\ n") ; setzt d ie W erte in d ie 0 }, 0,}, 0,}, 0,}, 0,},

Zeileninitialisierung kann fehlen, wenn das Feld anschlieend initialisiert wird.

F eld in itia lisieru n g

e n tsp rec h e im F e ld

n d e S telle n

11. Strings (Felder von Zeichen):

 Stringerzeugung : oder : Beispiel:

char textfeld[ ] = hallo; char *textfeld = hallo;

intern dargestellt durch : [ h ][ a ][ l ][ l ][ o][ \0] \0 kennzeichnet das Ende eines Strings

main ( ) { char *wochentage[] = { " Montag"," Dienstag "," Mittwoch", " Donnerstag "," Freitag ","Samstag ", "Sonntag" }; int pos; for ( pos= 0; pos< 7; pos++ ) { printf ("\ n % s", wochentage[ pos ]); } }

Ausgabe : Montag Dienstag Mittwoch Donnerstag Freitag Samstag Sonntag

Strings in Zahlen umwandeln : ~ String Fliesskomma: aber: ~ String ganze Zahl : aber :

double x = atof (char *c) #include <math.h> int n = atoi (char *c) #include <stdlib.h> int laenge = strlen (char *c) #include <string.h> *Zeigername;

main ( ) { double x x = atof (2.4354); printf(%lf, x); }

Lnge eines Strings : aber:

12. Zeiger:
Zeigertyp int *zeiger; ~ Ein Zeiger kann whrend des Programmablaufs seine Speicheradresse wechseln (variable Konstante) ~ Zeiger knnen auf beliebige Typen (int, float, char) aber auch auf ganze Felder zeigen, sowie auch Zeiger auf Zeiger erlaubt sind. Achtung: Der Zeigertyp und der Variablentyp/Feldtyp, auf das der Zeiger zeigt, mssen gleich sein ( 77 fload zeiger = &int *zahl 77 : Fehler !!! ) scanf (...) fscanf(stdin, ...) printf (...) fprintf (stdout, ... ) fprintf (stderr, Fehler aufgetreten in der Datei xyz.bat)

13. Standardkanle:

stdin (Standardeingabekanal ist die Tastatur) : ist identisch mit: stdout (Standardausgabekanal ist der Bildschirm) : ist identisch mit: stderr (Standardfehlerkanal) :

14. ffnen und Schlieen einer Datei:

Der Variablentyp FILE *datei, enthlt Informationen ber die zu bearbeitende Datei, die #include <stdio.h> wird bentigt : z.B. : FILE *datei; datei = fopen (test.dat, w+); datei entspricht der Dateivariable !!! fopen (zum ffnen einer Datei) : Dateivariable = fopen (Dateiname, Arbeitsmodus ); Arbeitsmodus: r w a nur zum Lesen ffnen, die Datei mu existieren nur zum Schreiben ffnen, wenn eine Datei existiert wird sie vorher gelscht nur zum Anhngen ffnen, wenn keine Datei existiert, wird sie angelegt (die Fileendmarkierung EOF wird nicht gelscht) datei = fopen (datei, wt); /* Variablenvereinbarung */ /* erzeugt eine Datei namens test.dat */

r+ w+ a+

zum Lesen und Schreiben ffnen, die Datei mu existieren zum Lesen und schreiben ffnen, wenn die Datei nicht existiert, wird sie erzeugt nur zum Anhngen ffnen, wenn keine Datei existiert, wird sie angelegt (die Fileendmarkierung EOF wird gelscht)

zustzliche Angaben: (werden dem Arbeitsmodus angehngt) b Binrmodus: alle Daten werden ohne Umwandlung in die Datei geschrieben t Textmodus: einige Daten werden umgewandelt (z.B. \n) fclose (zum Schlieen der Datei) : fclose (Dateivariable); fclose (datei);

16. Lesen und Schreiben von Daten :

fscanf : (Die Funktion fscanf liest Informationen aus einer Datei) fscanf (Dateivariable, Variablentyp, Variablenname) Lesen von der Tastatur: bzw. : scanf (%c, &zeichen); fscanf (stdin, %c, &zeichen); fscanf (datei, %c, &zeichen);

fprintf : (Die Funktion fprintf schreibt Informationen in eine Datei) fprintf (Dateivariable, Variablentyp, Variablenname); fprintf (datei, Zahl = %d, zahl);

getc und putc : Mit dieser Funktion hat man die Mglichkeit, Zeichen von (und nach) einer Datei einzeln einzulesen und auszugeben: char getc (Dateivariable)
liefert als Rckgabewert das bergebene Zeichen oder EOF

char putc (char zeichen, Dateivariable)

Liest ein Zeichen aus der Datei bzw. EOF

17. Strukturen:
struct Strukturname { Komponenten }; Hinweis: Die Komponenten mssen nicht den gleichen Datentyp haben. Benutzung der angelegten Struktur : struct Strukturname Feldname[Feldgre]; struct datensatz freunde[10]; struct { }; datensatz char name[50]; char vorname[50]; char telefon[50];

Legt ein Feld mit der entsprechenden Feldgre an und jedes Feld wird mit der entsprechenden Struktur angelegt. Im Beispiel: Es wird ein Feld mit 10 Eintrgen vom Typ datensatz definiert. Es knnen also die Adressen von 10 Freunden verwaltet werden. Oder krzer: struct Strukturname { Komponenten } Feldname[Feldgre]; struct { struktur int zahl; char *text; } *zeiger; struct { } datensatz char name[50] char vorname[50]; freunde[10];

Zeiger auf Strukturenelemente :

Zugriff auf ein Element : oder : Beispiel:

(*zeiger).zahl; zeiger->zahl;

int main ( ) { struct komplexeZa hl { double realTeil ; double imaginaerT eil ; } zahlenFeld [ 2 ];

/* die Variable zahlenFeld wird mittel seiner Struktur deklariert

*/

zahlenFeld [ 0].realTeil = 2.5; zahlenFeld [ 0].imaginaerT eil = 2; zahlenFeld [1].realTeil = 5; zahlenFeld [1].imaginaerT eil = 1.4;

/* den Einzelelem enten werden Werte zugewiesen

*/

printf ("\ n 1. komplexe Zahl : % lf + j % lf \n", struktur [ 0].realTeil , struktur [ 0].imaginaerT eil ); printf ("\ n 2. komplexe Zahl : % lf + j % lf \n", struktur [1].realTeil , struktur [1].imaginaerT eil ); }

17. Variablen:

Lokale Variablen:

werden in Funktionen vereinbart und sind nur hier sichtbar und gltig.

#include <stdio.h> int k=4; int fakulteat (int n) { int i, wert=1; } void main (void) { int zahl;

Globale Variablen: werden auerhalb von Funktionen vereinbart und sind in allen Funktionen sichtbar. Hinweis: Globale Variablen sollten nur in Ausnahmefllen benutzt werden, da sie hufig inhaltliche Fehlerquellen darstellen.

Funktionsparameter: sind die Speicherpltze, die bei der Ausfhrung des } Unterprogramms Werte vom Hauptprogramm erhalten, die fr Berechnungen notwendig sind. bergabe von Funktionsparametern: ~ Call by value: Eine nderung von Funktionsparametern im int verdoppe ln (int n ) Unterprogramm bewirkt keine nderung des entsprechenden Wertes im Hauptprogramm.
{ n = n*2 }

Ausgabe: 3

void main ( void ) { int zahl = 3; verdoppe ln ( zahl ) printf (" Die Zahl lautet jetzt : % d ",zahl ); } int verdoppe ln (int *n ) { *n = *n * 2 } void main ( void ) { int zahl = 3; verdoppe ln (&zahl) printf (" Die Zahl lautet jetzt : % d ",zahl ); }

~ Call by reference: Eine nderung von Funktionsparametern im Unterprogramm bewirkt eine nderung des entsprechenden Wertes im Hauptprogramm.

Ausgabe: 6

gnjcnhk