Programmieren in C

1. Einfhrung \n neue Zeile, \t Tabulator, \b lsst vorheriges Zeichen weg

2. Variable Prprozessor: (Vor-Compiler ) Bereitet die Dateien um, bevor sie vom Compiler weiterverarbeitet werden Compiler : Sammler (lat.) Sprachbersetzter, bersetzt den Quellencode auf einmal Linker: (Binder) Bindet das bersetzte Programm mit anderen Dateien zusammen
Quellendatei .c Prpro zessor Quellendatei mit expandierten Prprozessorkommandos .i Assemblerdatei Compiler .s Assembler Objektdatei .o Linker .exe e

3. Ein- und Ausgabe

literale Konsatante = Feste Zuweisung eines Wertes zu einer Variable, z.B. b=5 Formatstring = Text in den Hochkommadata Umwandlungsangabe %d %ld %c %e %le Assoziierter Typ int long char float double

A%B ergibt den Restwert von A/B

Wenn der Eingabewert int als Ausgabewert char ausgegeben wird, so schreibt er den ASCI-Wert. Das Ganze funktioniert auch umgekehrt.(char mit %d/%c oder int mit%c) %010d bedeutet, dass die letzte Zahl mit 10 Stellen steht. Das 0 vor der 10 fllt die Zahl mit 0 auf.

4. Ein und Ausgabe putchar ( ) und getchar lesen oder schreiben ein Zeichen. !putchar enthlt ein Argument vom Typ int und liefert den Rckgabewert vom Typ int. c=getchar ( ); Ein einzelnes Zeichen wird vom Bildschirm eingelesen. C =putchar(72); Asci- Wert wird auf den Bildschirm ausgegeben (H) Putchar (c); zeichen wir auf den Bildschirm geschrieben (H) scanf (\n%d,&zahl); der Adressoperator & und \n ist notwendig!! 6. Extended Backus Naur Form (EBNF) Metazeichen Definition ::= trennt die linke und die rechte Seite einer Produktion Alternative | A|B bedeutet, dass A oder B mglich ist Option [] [A] bedeutet, dass A vorkommen kann oder nicht Iteration{} {A} bedeutet, dass A 0 bis unendlich mal vorkommen kann Bereich.... A...B alle Buchstaben zw. A und Z knnen enthalten sein Ziffer ::= 0...9 Nichtterminalsymbol 8. Selektion if
Operator == != > < >= <= ! && || Beispiel X == 5 X! = 5 X>5 X<5 X >= 5 X <= 5 !A A && B A || B Bedeutung X gleich 5 X ungleich 5 X grsser 5 X kleiner 5 X grsser oder gleich X kleiner oder gleich 5 NOT A A AND B A OR B

Terminalsymbol meistens fett

Selektion if (unwahr),

if ( Bedingung) { } else { }

Achtung: Ist die Bedingung null so springt er direkt in das else.

9. Zuweisung enum namen {URS=1, SEPP,BEAT} SEPP erhlt automatisch die Nummer 2 usw. 10. Case select heisst switch in C (siehe auch Beispiel in Kapitel 22) switch (Expression) { case 1: printf (Montag\n) ; break; //ohne das break wrden alle default: printf (Mittwoch\n) ; break; Flle berprft, default bedeutet else

11. While Schleife while (Bedingung) { } else { }

Beispiel

while (a==b){ printf (a ist gleich b \n ); } else { printf (Hallo Donald Duck\n ) ;}

Postfix- Dekrement- Operator A-Postfix- Inkrement Operator A++ Prfix- Dekrement- Operator A Prfix- Inkrement- Operator ++A 12. FOR Schleife, auch Kopfgesteuerte Schleife for ( i =1; i <= 10; i++) { printf (Dies wird nur geschrieben wenn i<=10); } mit break verlsst man die Schleife und mit continue springt man zum Testausdruck (Durchfhrkriterium bzw. Abbruchkriterium bei der for Anweisung i++) zurck. 13. Iteration do while auch Fussgesteuerte Schleife Die do while Schleife hat ein Durchfhrkriterium, sie ist eine wiederhole .... solange Schleife. Die Verrichtung wird mindestens einmal ausgefhrt. do { a=a*b; } while (a<30); 14. Bedingungsoperator zahl3 = (zahl1 > zahl2) ? zahl1 : zahl2; wenn die Bedingung in der Klammer wahr ist dann zahl3=zahl1 sonst zahl3=zahl2 if (expr1) {expr2;} else {expresion3;} entspricht expr1 ? expr2 : expres3

Wenn expr1= 0, dann sofort expr3 15. Vektoren Array Ein Array erlaubt es mehrere Elemente eines Datentyps hintereinander und zusammenhngend in einer Variable abzuspeichern. Definition: Sollte zuerst folgen wie int name [5] ; oder int name [5*3-2]; [] wird Feldindexoperator genannt Achtung ! ein Array[10] geht von [0..9] es gibt keine [10] !!!! Initialisierung Ausgeben: Arbeiten mit Arrays : z. B. int zahlen [10] = {1,2,3,4,5,6,7,8,9,10}; int zahlen [10] = 15; /* die Arrays [1]-[9] haben somit den wert null, sofern die
Arrays global sind.*/

printf(Wert ist %d, zahlen [7]); y=5*zahlen[3]%4; (Restwert)

Matrix

int martrix [2] [3] = {{1,2,3},{3,7,9}}; wobei int matrix [Zeile][Spalte]

Es muss nicht immer eine Zahl in die brackets geschrieben werden, es kann auch am Anfang definiert werde wie #define ALT 10 (anschliessend kein ;) und dann int array [ALT]; /*kann auch spter im Programm wieder rckgngig gemacht werden, mit #undef ALT (auch ohne Semikolon */ char string [13] = { G,U,T,E,N,\0}; Das \0 muss vorhanden und einberechnet sein Einlesen auch mglich mit char string [] = Guten Morgen; Ausgabe : printf (%s\n, name); hier braucht es keinen Adressoperator & !!!!! Einlesen: scanf(%20s, string) keinen Adressoperator & !(Es knnen max. 20 Zeichen eingelesen werden, zum Schutz) 16. Parameter Funktionen ( Funktion = Unterprogramm = Teil eines Programm)

1. Deklaration Am Anfang des Programms ist die Deklaration wie void hello (void) 2. Definition In der Definition werden die Aufgaben der Funktion festgelegt 3. Aufruf Der Aufruf erfolgt meinstens im Programm main void donald (void) void knnte weggelassen werden z. B.( ) es zeigt, dass kein Parameter von main zu donald mitgenommen wird, genannt Parameter z.B. (int zahl) oder (int zahl, char zeichen)

Funktionsname Bezeichntet, dass es keinen Rckgabewert hat , bei einem Rckgabewert wrde int anstatt void stehen, es whre im main Programm das return wert; notwendig . Beim Aufruf im Programm main ist z. B. a = donald ( );
#include <stdio.h> long division (int a, int b) { long ergebnis; ergebnis = a/b; return ergebnis; } void main (void) { int zahl1, zahl2; printf(Bitte geben sie eine Zahl ein:\n); scanf(%d,zahl1); printf(Bitte geben sie eine zweite Zahl ein:\n); scanf(%d,zahl2); a = division (zahl1, zahl2); printf(Die Division von %d und %d ist %ld,zahl1,zahl2, a); }

Eine Funktion mit Parametern kann auch mit festen Werten ( Literale Konstanten ) im Hauptprogramm aufgerufen wie quadrat (3,16); Lokale Variable: Variable die innerhalb einer Funktion definiert ist und auch nur innerhalb der Schleife gltig ist. Globale Variable: Variable die ausserhalb einer Funktion definiert ist , die immer gltig ist. 17. Kellerspeicher, Stack & Stapelspeicher (Lifo Prinzip) 19 Strukturen Strukturen sind Elemente in denen unterschiedliche Datentypen gespeichert werden knnen.
struct [TypName] { Komponente_1; [ Komponente_2; Komponente_n; ] }[VarName {,VarName}]; struct adr_typ{ char name[20]; char vorname[20]; ... char ort[20]; }adressen[25]; adresse definiert die Variable namens Adresse.

Auf die Elemente wird wie folgt zugegriffen: (Bei String ist kein & erlaubt)
scanf (%19s, adresse.name); scanf (%d, &adresse.plz); printf (Der Name lautet: \n%s, %s, adresse.name, adresse.vorname);

Oder auch scanf(%d,&adressen[30].plz); /* wenn die Adressen in ein Array gegliedert wurden*/

Man kann der Struktur auch einen Namen zuweisen, damit sptere Variablen mit derselben Struktur definiert werden knnen.
struct adr_typ{char name[20]; char vname [20];...; }; Initialisierung: Struct adr_typ adresse1 = {Jauch,Hans,Bltschi, 12,6320,Stans};

Zuweisungsoperator: z.B: adresse1=adresse2. Ergibt, dass in der Adresse1 den Inhalt der Adresse2 kopiert wird.

20 Unionen Eine Union ist eine Variable, die Werte von verschiedenen Datentypen annehmen kann. Syntaktisch sind Strukturen und Unionen gleich, nur wird das Wort struct durch union ersetzt. Whrend in einer Struktur alle Elemente gleichzeitig gespeichert werden, kann eine Union immer nur ein Element speichern. Die folgende Union enthlt beispielsweise einen int, float oder char-Wert:
Union zeichen {int ival; float fval; char cval;} u_value;

Der Compiler reserviert so viel Speicherplatz, wie das grsste Element der U bentigt. Ein Zugriff wrde wie folgt aussehen:
u_value.ival=5

21 Projektverwaltung #define, #if, #ifndef, #endif, #include,

Schlsselwort auto const extern register static volatile Verwendung in Funktion Automatische Vernichtung nach der Fkt. auto int i; Variable kann nach Def. Nicht verndert werden Deklaration einer globalen Variable aus einer anderen Qelldatei. Wie auto jedoch schneller erreichbar Interne statische Var. Nur dort sichtbar wo sie def. wurde Variable kann asynchron verndert werden Verw. ausserhalb Funktion Nicht erlaubt Variable kann nach Def. Nicht verndert werden Delaration einer globalen Variable aus einer anderen Quelldatei Nicht erlaubt Modulweite statische Var. Erst sichtbar ab Def.stelle Variable kann asynchron verndert werden

22 Selbstdefinierte Datentypen Die Syntax fr einen selbstdefinierten Datentypen sieht wie folgt aus:
Typedef Typ TypName typedef int ganzzahl

Somit kann ich in diesem Programm eine Zahl mit ganzzahl definieren: ganzzahl zahl; Es knnen auch andere Typen kreiert werden:
typedef enum {FALSE, TRUE} bool;
#include<stdio.h> typedef enum {MO=1, DI, MI, DO, FR, SA, SO} wochentag; wochentag tag; void main () { /* Lies Zahl zwischen 1 und 7 ein fr einen Wochentag */ printf ("Geben Sie eine Zahl zwischen 1 und 7 ein.\n"); scanf ("%d",&tag);

typedef char string[20]

switch (tag) { case MO : case MI : case DO : case FR : printf ("Werktag\n"); break; case SA : case SO : printf ("Wochenende\n"); break; default: printf ("Fehlerhafte Eingabe\n"); } /* end switch */ } /* end main */

23 Bitweise Operatoren und Bitfelder Die interne Darstellung in einem Computer besteht aus Bits. C erlaubt es mit diesen Einsen und Nullen Operationen durchzufhren. Der Datentyp mit den wenigsten Bits ist unsigned char. Hier wird 1 Byte / 8 Bit alloziert. Beispiel: Unsigned char A=29 Das Bitmuster lautet 00011101
Bitweises und: &

Beim bitweisen Und wird das erste Bit von A mit dem ersten Bit von B verglichen, um das erste Bit von C zu berechnen. Sind beide Bits Eins, so erhlt das erste Bit von C den Wert1, andernfalls den Wert 0, danach wird das zweite Bit berechnet, usw...

C=29&117 00011101 & 01110101 = 00010101

Bitweises oder: | Hier werden die Bits von A und B nacheinander mit oder verknpft
C=29|117 00011101 | 01110101 = 01111101

Bitweises Exclusiv oder (XOR): ^ Beim bitweisen XOR wird die XOR-Operation bitweise auf die Bits von A und B angewandt. Die Wahrheitstabelle sieht wie folgt aus:
A B A XOR B 0 0 0 0 1 1 1 0 1 1 1 0 C=29^117 00011101 ^ 01110101 = 01101000

Linksschiebe-Operator: X<<Y / Rechtsschiebe-Operator X>>Y Bei den Links- bzw. Rechtsschiebe-Operatoren wird jedes Bit um Y Stellen nach links/rechts geschoben, die Stellen die dann rechts/links frei werden, werden mit Nullen gefllt.
C=29<<1

Einerkomplement-Operator: ~A Der Einerkomplement-Operator invertiert jedes Bit, d.h. aus Null wird Eins und aus Eins wird Null.
C=~29

Bitweise Zuordnungsoperatoren Die Bitweisen Operatoren knnen mit dem Zuordnungsoperator = kombiniert werden:
Zuweisungsoperator Entspricht A+=B A=A+B A&=B A=A&B A|=B A=A|B and so on...

Bitfelder Mit einem Bitfeld kann Speicherplatz gespart werden. Gehen wir dabei von folgendem Beispiel aus:
Struct display { unsigned char linie1:1 unsigned char linie2:1 unsigned char linie3:1 }ziffer_display; :1 ist dabei das Bitfeld und ist genau ein Bit gross.
1 2 4 5 7 6 3 Linie1 Linie2 Linie3 Linie4 Linie5 Linie6 Linie 7

24 Rekursion Man kann viele Probleme einfacher lsen, indem man die Befehle ineinanderschachtelt.Eine Rekursion besteht aus einer Rekursionsbasis (beschreibt wie ein einfaches Problem der angegebenen Problemklasse gelst werden kann) und einer Rekursionsvorschrift (gibt an wie ein Problem auf ein einfacheres Problem zurckgefhrt werden kann). Rekursion am Beispiel einer Fakultt:
Fakultaet (n) { if ((n=0)||(n=1)) {Ergebnis=1} else {n * Fakultaet(n-1)}
Das ! bedeutet Fakultt Man muss mit Hilfe der Rekursionsvorschrift immer auf die Rekursionsbasis kommen. Rekursionsbasis: 0! = 1 1! = 1 Rekursionsvorschrift: n! = n ( n 1 )

25 Zeiger (Ein Zeiger ist eine Variable, die als Wert die Adresse einer anderen Variablen aufnehmen kann.) Ein Zeiger auf einen Speicherbereich wird wie folgt definiert:
Datentyp *Name int *izeiger
(Der Zeiger zeigt auf einen int)

Achtung! bei Zeigern immer auf den Datentyp achten (ein auf int definierter Zeiger kann beispielsweise kein char aufnehmen)!!

Ein Zeiger auf einen Struct she wie folgt aus:

(*szeiger).zahl = 5
Int zahl = 5; Int *izeiger; Izeiger = &zahl Printf (%d, *izeiger); Printf(%ld,izeiger);

entspricht
Ausgabe:

szeiger->zahl = 5
Definition Zeiger auf einen int Izeiger bekommt die Adresse der Zahl 5 Der Wert des Inhaltes des Zeigers kommt auf den Bildschirm Die Adresse des zeigers auf die zahl wird auf den Bildschirm geschrieben

Z.B Z.B

5 4B7F:0A26

Mit dem Adressoperator & kann die Adresse einer Variablen ermttelt werden und diese einer Zeigervariablen zugewiesen werden. Der Zuweisungsoperator = kann einem Zeiger einen neuen Wert zuweisen, der neue Wert muss jedoch auch ein Zeiger sein.

Derefenrenzierung von Zeigern Ein Zeiger enthlt die Adresse einer Variablen, um nun auf den an der Adresse gespeicherten Wert zugreifen zu knnen, wird der unre Umleitungsoperator * bentigt. Wenn beispielsweise zeiger eine Zeigervariable ist, die auf eine int-Variable zeigt, so enthlt *zeiger den Wert der int-Variable
Beispiel: Char zeichen = a Char *zeiger = &zeichen; zeichen &zeiger Ist die Variable Adresse der a Variable zeiger zeigt auf die Adresse der Variable *zeiger Ist Inhalt der Adresse der Variablen, somit a

Assert Die Funktion assert testet den Code. #include <assert.h> Test ist ein logischer Ausdruck, der ausgewertet werden void main (void) { kann. Wenn der Ausdruck nicht gltig ist, bricht das assert(zahl != 0)} Programm ab. (Wenn zahl = 0, dann Abbruch.) Speicherallozierung mit malloc Nachdem ein Zeiger mit int *izeiger definiert wurde, so muss ihm mit Malloc noch einen Speicherplatz zugewiesen (alloziert) werden, denn bis jetzt zeigt dieser einfach irgendwohin.
#include <stdlib.h> oder <alloc.h> void *malloc (size_t size) malloc (sizeof (int))

Um die Funktion aufrufen zu knnen, muss der Parameter size bergeben werden, dieser gibt die Grsse des zu allozierenden Bereichs an Der korrekte Code, um einem Zeiger auf eine intVariable Speicherplatz zuzuweisen, sieht wie folgt aus:
int *zeiger zeiger=(int*) malloc (sizeof (int)) entspr.

sizeof bestimmt die Speichergrsse

automatisch. Falls es im Speicher nicht mehr gengend Platz hat, wird NULL zurckgegeben. Die Typumwandlung des Zeigers in einen Zeiger auf eine int-Variable erfolgt auch automatisch. Deshalb ist folgender Code auch korrekt:
zeiger=malloc (sizeof(int))

Wenn malloc nicht gengend Speicherplatz reservieren kann, so sollte eine Fehlermeldung ausgegeben werden:
if ((zeiger=(int*) malloc (sizeof(int))) == NULL) /*Fehlermeldung*/ Oder:
assert ((zeiger = (int *) malloc (sizeof (int))) != NULL);

Speicherfreigabe mit Free Wenn der Speicherplatz mit malloc alloziert wurde, so muss dafr gesorgt werden, dass der Speicher wieder freigegeben wird. Dies erfolgt mit dem Befehl free: Der vorhin allozierte Zeiger kann also wie #include <stdlib.h> free (zeiger); //ohne * vor zeiger folgt freigegeben werden: Es kann nur Speicherplatz freigegeben werden, wenn dieser vorhin mit malloc alloziert wurde! 26 Implementation eines Stacks mit Zeigern (siehe Beispiel Ende 8 S.) Beispiel: Struct stype { int zahl; Zugriff:
Char zeichen; Char string[81]; }; (*szeiger).zahl = 5; entspricht szeiger->zahl = 5;

Struct stype *szeiger;

27 Call-by-value und call-by-reference Parameter Die Sichtbarkeit der formalen Parameter beschrnkt sich auf den Funktionsrumpf ( wie globale Variablen), aktuelle Parameter werden beim Aufruf an die Funktion bergeben. Call-by-reference Parameter sind Parameter die von einer Funktion dauerhaft verndert werden knnen (im gegensatz zu den call by value), dies kann mittels Zeigern realisiert werden. Wenn einer Funktion beispielsweise ein int-Parameter bergeben werden soll, der in der Funktion verndert werden kann, so wird ein Zeiger auf einen int-Parameter bergeben:
void eingabe (int *zahl) { scanf (%d, *zahl) }

Da dies ein Zeiger ist, darf der Adressoperator nicht angewendet werden

Um die Funktion eingabe aus main aufzurufen, wird entweder eine Zeigervariable bentigt , oder der Adressoperator muss angewandt werden:
Void main (void) { int zahl; eingabe (&zahl); printf (Die Zahl; %d\n,zahl); } void main (void) { int *zeiger; zeiger = (int*) malloc (sizeof (int)); eingabe (zeiger); printf(%d.\n,*zeiger); }

entpr.

28 Arrays und Zeiger Ein Array kann nicht nur auf ein einzelnes Element, sondern auch auf einen Array zeigen.
int zahlen [100];

Zahlen ist also ein Zeiger, der auf das erste Element des Arrays namens Zahlen zeigt. *zahlen ergibt somit denselben Wert wie zahlen[0]. Es gibt folgende Unterschiede zwischen Arrays und Zeigern: Bei der Definition eines Arrays wird automatisch Speicherplatz zugewiesen, bei einem Zeiger muss dieser erst mittels malloc reserviert werden. Man kann einer Arrayvariable keinen anderen Speicherplatz zuweisen. Mittels Zeigerarithmetik kann man Zeiger als Array benutzen; Beispiel:
int zahlen[5] = {1,2,3,4,5} *zahlen verweist dann auf den Wert 1, (zahlen+2) verweist auf den Wert 3, usw. Um den

Wert dieser Speicherstelle zu erhalten, muss der unre Umleitungsoperator angewandt werden. *(zahlen+2) zeigt somit den Wert von zahlen[2]. Achtung: bei *zahlen+2 wird der Wert von zahlen[1] genommen und 2 addiert!!! Void main (void) Void main (void) Ausgeben:
{ int zaehler; for (zaehler =0; zaheler<5;zaehler ++){ printf(%d\t, zahlen [zaehler] ); } } oder

{ int *z = zahlen; int zaehler; for (zaehler =0; zaehler<5; zaehler ++) { printf(%d\t, *(z++)); }

29 Strings und Stringverwaltung Es gibt diverse Funktionen, mit denen ein string (Zeichenkette, Array) manipuliert werden knnen. Die aufzurufenden Definitionsdatei lautet string.h.
Funktion Anwendung strlen strlen (string) strcat char *strcat ( char *dest , const char *src); strncat strcmp int strncat (char *dest, const char *src, size_t len); int strcmp ( const char * s1, const char *s2); Rckgabewert size_t in ld Zeiger auf zusammengefgten String Liefert den Hauptstring zurck Keinen Aufgabe Berechnet die Anzahl Zeichen in dem String Hngt einen String an einen anderen Hngt einen Teilstring an einen anderen von der Lnge n Vergleicht zwei Strings zeichenweise, bis zwei Zeichen ungleich sind, oder das Ende erreicht wird Vergleicht Anzahl von Zeichen bis ungleich, oder fertig Kopiert einen String an einen anderen. dest wird durch src berschrieben Kopiert eine bestimmte Anzahl von Bytes an einen String. Kopie des Strings src an die durch dest bez. Stelle. Hchstens len Zeichen. Kopiert einen String in einen neuen Speicherbereich Kopiert n Bytes von einem String an einen anderen gibt dest zurck

strncmp strcpy strncpy

int strncmp (const char*s1,const char *s2, size t_len); char *strcpy ( char *dest, const char *src);

Einen int-Wert, je nach Vergleich Liefert den Hauptstring zurck char *strncpy ( char *dest, const c har *src, size_t Liefert den Hauptstring len); zurck char *strdup ( const char *); void *memcp y (const void *dest, const void *src, size_t size); Zeiger auf den neu reservierten Bereich Liefert bergebenen Parameter zurck

strdup memcpy

memcmp

Int memcmp (const void *buf1, const void bur2, size_t size);

Je nach Vergleich: <0 s1 kleiner s2 = =0 die ersten n Zeichen von s1+s2 sind gleich:>0 1 grsser als 2.

Vergleicht die ersten n Bytes und behandelt diese als unsigned char

30 Programmargumente Der Funktion main werden mittels Programmargumenten Parameter bei Aufruf bergeben. Als erstes Argument wird eine int-Zahl bergeben. Diese Zahl gibt die Anzahl der Argumente des Programms an (der Programmname *.exe ist dabei auch ein Argument). Dieses Argument erhlt normalerweise den Namen argc (Argument counter). Das zweite Argument ist ein Array, in dem die Argumente als Strings abgespeichert sind. Dies trgt normalerweise den Namen argv (argument vector).
void main (int argc, char *argv[]) { } args.exe eins 2 drei 4

entspricht

void main (int argc, char **argv) { }

Die Argumente werden dem Programm beim Start bergeben:

Dann hat argc den Wert 5, argv[0] = args.exe, argv[1] = eins, argv[2] =
2, etc...

31 Dateiverwaltung in C Die Dateiverwaltung erlaubt es, dass Dateien dauerhaft verndert werden knnen, ohne dass die Information nach dem Beenden der Datei verloren gehen. Die Dateien sind in C unstrukturiert abgelegt, mit Hilfe der Dateiverwaltung Strukturiert C das Programm.
Modus r w a r+ w+ a+ Modus t b Bedeutung ffnet Datei zum lesen Legt eine Datei zum schreiben an ffnet Datei zum schreiben ans Ende der Datei(ev.neu) ffnet existierende Datei zum verndern Legt Datei an zum Verndern/ lscht Datei mit diesem Namen Offnet angegebene Dateien zum lesen & schreiben am Ende/ legt neue Datei an Beschreibung Textdatei; nur lesbare Textzeichen zulssig Wird im Binrmodus geffnet, keine konventierung von Zeichen Rckgabe von Null Datei exisitert nicht/keine Berechtigungd Datei kann nicht angelegt werden/keine Schreibbereichtigung Benutzer darf Datei nicht anlegen oder beschreiben Dat. Nicht existent/ keine Berechtigung Vorhandene Datei beschr. Werden kann/ kein Einrichten der Datei mglich Vorhandene Datei kann nicht gelesen oder beschrieben werden/ Berechtigung zum anlegen fehlt
#include<stdio.h> #include<stdlib.h> #include<assert.h> #define ERROR -99

Zu KP 26 Stack (Ohne main)

typedef struct e2 { int wert; struct e2 *next; } element2; element2 *stack = NULL; int top (void); void push (int); void pop (void); void ausgabe (void); int top (void) { if (stack == NULL) { return ERROR;} return stack->wert;} vvoid push (int zahl { element2 *help; help = (element2 *) malloc (sizeof (element2)); assert (help != NULL); help->next = stack; stack = help; stack->wert = zahl; return;} void pop (void) { element2 *help; if (stack == NULL) { printf ("Error, pop auf leeren Stack!\n"); return;} help = stack; stack = stack->next; free (help); return;} void ausgabe (void) { element2 *help = stack; while (help != NULL) { printf ("%d ", help->wert); help = help->next;} printf ("\n"); return;}

#include<stdio.h> FILE *osterhase; Zu Kap 30-31 FILE *weihnachtsmann; int zeichen; void main (void) { osterhase = fopen("ostern.txt", "r"); weihnachtsmann = fopen("weihn.txt", "w"); zeichen = getc (osterhase); while (zeichen != EOF) { putc (zeichen, weihnachtsmann); zeichen = getc (osterhase);} fclose (osterhase); fclose (weihnachtsmann);}