Funktion:

• Einziger Typ Unterprogramm in C
• In sich geschlossener Programmabschnitt eine Funktion hat einen Namen (Bezeichner),über den sie aufgerufen werden kann.
• Erfüllt eine genau umrissene Aufgabe.
• Eine Funktion kann beim Aufruf Parameter übernehmen, keinen, einen oder mehrere.
• Die Funktion hat immer einen Rückgabetyp. Ist dieser nichtvoid, so gibt die Funktion einen Wert zurück, der zugewiesen wird. Ist der Rückgabetyp void, so gibt die Funktion keinen Wert zurück!

• bessere Wiederverwendbarkeit bestehender codes
• im aktuellen Quelltext
• in späteren Quelltexten à Modularisierung
• bessere Pflegbarkeit/ Übersicht à Minimierung von Fehlern
• Black- Box- Effekt:
• Ist eine Funktion getestet und o.k., so reicht es zu wissen, wie ihr Prototyp ist und was sie inhaltlich tut um sie sinnvoll einzusetzen zu können. Man braucht nicht zu wissen, wie eine Funktion ihre Arbeit erledigt.
• Bessere Handhabbarkeit in Projektgruppenà Arbeitsteilung

{

{

}

Prototyp: double pi (void);

Funktionsdefinition: double pi ( )

• Wenn die letzte } des Funktionsblockes erreicht ist.
• Wenn das reservierte Wort RETURN erreicht wird. Hat die Funktion einen Rückgabetyp

!= void, so ist bei RETURN ein Ausdruck anzugeben. Der Wert dieses Ausdruckes ist dann

Prototyp: double viereck ( double a, double b);werden im Compiler überlesen

Rückgabetyp Name Parameterliste

# include <.......> Standart- Includes

====
 

Prototypen für eigene Funktionen Reihenfolge der Prototypen ist beliebig

====

Implementierung eigener Funktionen

= Funktionsdefinitionen

= Quelltext der Funktionen

Variablen in der Parameterliste einer Funktion und lokale Variablen einer Funktion

• Variablen, die innerhalb einer Funktion deklariert sind.
• Werden deklariert nach der ersten { des Funktionsblockes noch vor den ausführbaren Anweisungen.
• Werden zwischen ( und ) des Funktionskofs deklariert.
• Diese Variablen in der Parameterliste übernehmen die Werte, die beim Funktionsaufruf übergeben werden.

Sichtbarkeit: nur innerhalb der Funktion/des Programm- Blocks, in dem sie deklariert sind.

"lokale" Variablen

return x * y;

}

void main()

{

int a, b, c;

a = 5; b = 7; zu main() lokale Variablen

c = mult1 ( a , b );

57

printf ( "%d\n",c ) ;

printf ( "%d\n",a ) ;
 
 

Regel:

die aktuellen Parameter beim Funktionsaufruf müssen mit den formalen Parametern der Funktion in Anzahl, Typ und Reihenfolge übereinstimmen.
 

• Werden "normale" Werte übergeben (keine Adressen) spricht man von einem "Call by Value"
• Prinzipiell enthalten die formalen Parameter Kopien der Inhalte der aktuellen Parameter des Funktionsaufrufs.

}

void main()

{

int a, b, c;

4020

a = 5; b = 7;

mult2 ( a , b ,&c);

57

printf ( "%d\n",c ) ;

printf ( "%d\n",a ) ;
 
 

}

void main()

{

int a, b, c;

a = 5; b = 7;

mult2 ( a , b );

57

printf ( "%d\n",c ) ;

printf ( "%d\n",a ) ;
 
 

Stack
 

Rückspr.-Adr

5

7

• lokale Variablen
• formale Parameter
• Rücksprungadressen

Bsp.:

Prototyp: void bubble (int * , int ) ;
 
 

Funktionsdefinition:

void bubble ( int * f , int n )

Für lokale und globale Variablen gleichen Namens gilt:

Im Sichtbarkeitsbereich der lokalen Variable ist kein Zugriff auf die globale Variable gleichen Namens möglich. ( K&R, ANSII - C )

Funktionen, die Arrays verarbeiten, hier: Strings 28.09.1999

Void main()

{

char f1[81], f2[81];

int i;

gets (f1);

i = s_len(f1); Stringlänge

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

printf("%d\n", s-len("Hallo"));

(s.o. "typdef")

Void main()

{

char f1[81], f2[81];

int i;

gets (f1);

i = s_len(f1);

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

printf("%d\n", s-len("Hallo"));

s_cpy(f2,f1); Stringcopy

puts (f2);
 

printf("%d\n", atoi(s_cpy(f2,gets(f1) ) ) ) );
 
 

{

char f1[81], f2[81];

int i;

gets (f1);

i = s_len(f1);

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

printf("%d\n", s-len("Hallo"));

s_cpy(f2,f1);

puts (f2);

gets(f2);

s_cat(f1,f2); Stringverkettung

puts (f1);
 

s_cmp() : lexikalischer Vergleich der Strings

Standart- Funktion: strcmp()<string.h>

BlumenvaseÆgrHausÆkl AlfÆ

BlumentopfÆklhausÆgr AlfÆ

StuttgartÆklHoseÆkl

Stuttgart – NordÆgrSchuhÆgr

int s_cmp (char * st1; char * st2 ) ;

String1 String2

positiv wenn string1 "größer" string2

null wenn string1 gleich string2

negativ wenn string1 "kleiner" string2

Void main()

{

char f1[81], f2[81];

int i;

gets (f1);

i = s_len(f1);

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

printf("%d\n", s-len("Hallo"));

s_cpy(f2,f1);

puts (f2);

gets(f2);

s_cat(f1,f2); Stringverkettung

puts (f1);

i = s_cmp (f1 , f2 ); String umdrehen

printf("%s\n %s\n %d\n", f1, f2, i);

i = s_cmp ("Haus", "haus");

s_rev( f1 );

puts( f1);

puts( s_rev(f1));
 

s_rev () : String "umdrehen"

Borland- Funktion: strrev()

Prototyp: char * s_rev( char * st) ;

Adresse des "unzudrehenden" Strings
 

char * s_rev( char * st)

{

char *h, *v;

int z;

for( h=st ; *h ; h++ ) ; Leeranweisung

for( ---h , v=st ; v<h ; v++, h-- )

input ("Name", f1);

puts(f1);

input("Entfernung", f2);

x = atof(f2);

printf("%lf\n",x);
 

{

return 4.0 * atan(1.0);

double double

void main()

{

double d;

d = pi(); (3)

printf("%lf\n",d);

}

berifft: lokale Variablen

globale Variablen

Funktionen

betrachtete Aspekte: Sichtbarkeit

Lebensdauer
 

Übersicht:	auto	register	siatc	extern
lokale Variablen	(1) x	x	x
globale Variablen Ä			x	x
Funktionen Ä			x	(1) x

Voreinstellung

Äkommt erst zum Tragen, wenn der Quelltext auf mehrere Dateiein aufgeteilt wird, die getrennt übersetzt werden und dannn zu einer *.EXE Datei zusmmengefasst werden.

auto "automatic", Voreinstellung Stack

Sichtbarkeit: nur innerhalb des Funktionsblockes, in dem sie deklariert sind.

Lebensdauer: * Eintritt in den Pgm- block in dem sie deklariert sind:

beim Ende de Betreffenden Pgm- Blockes/ Funktion.
 
 

• solche Variablen behalten ihre Werte zwischen 2 Funktionsaufrufen nicht bei.
• Eine Funktion sollte nie die Adresse einer lokalen auto- Variable/Array zurückgeben, da diese Variablen am Ende der Funktion wieder abgebaut werden.

static Datensegment

Sichtbarkeit: weiterhin lokal

Lebensdauer: gesamte Programmlaufzeit

• solche Variablen behalten ihre Werte zwischen 2 Funktionsaufrufen bei.

Bsp.:

int wurfel()

{

static int i=1; Variable wird einmal zu Programmbeginn mit 1 initialisiert.

if(i)

{

srand(time(NULL));

i=0;

}

return rand()% 6+1;

}
 
 

lokale Variablen: register

Bsp: register int i ;

• geht nur für Variablen, die per Vor-

• geht nur für Datentypen, die iin ein

• Die Adresse von Variablen, die als register deklariert sind kann nicht mehr ermittelt werden, unabhängig davon , ob die Variable tatsächlich in einem Register liegt.

BC 3.1 als Bsp, verwendet für diesen Zweck- sofern noch übrig- die Register SI und DI

int i;

static int b;

void main();

{

funk99();

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

}

Compiler Compiler

teil1.obj teil2.obj
 
 
 
 

Linker Standatrbibliothek

progi.exe

Funktionen, die static deklariert sind, sind in ihrer Sichtbarkeit auf das Quelltextmodul beschränkt, in dem sie definiert sind.

Bsp.: static c int b_007()

{

?

retutn 7;

}
 
 

Verwendung:

1. Deklaration von Variablen, deren Inhalt dann nicht mehr geändert werden kann

 

 

---

Konstante.

Solche Variablen müssen bei der Deklaration gleich initialisiert werden.

Bsp.: const int x = 7 ;

int *p;

x = 13; Error

p = &x;

*p = 13;

Querverweis, siehe benannte konstanten mit #define

2. in der Parameterliste von Funktionen.

Der Compiler soll für so deklarierte Variablen keine Optimierung vornehmen. Macht Sinn für Variablen, deren Wert sich durch äußere Einflüsse (z. B. Interrupt) änden kann.
 
 

• Außer den "erlaubten" Zeichen müssen noch zugelassen werden: BACKSPACE 8 RETURN 13 nur, wen mindestens 1 gültiges Zeichen vorhanden ist !!! nur, wenn min erfüllt ist !!! Ist max erreicht, wird nur noch RETURN und BACKSPACE akzeptiert.

{

if ( z > = ’0’ && z < = ‘9’ ) return z ;

return 0;

}

int x;

x ASCII- Code;

if( keytest_n(x)) -------- ;

Bsp.- Aufruf: char f[81];

int int char* int int

char* string_in(int x, int y, char *f, int max, int min )

{

Lokale Variablen

• Eingabefeld zeichnen curpos(), Schl. putchar(‘_’); curpos();

}

Praktikum:

• string_in inplementieren
• MASTERM1.EXE

• Übergabe der Parameter : wie in ANSI- C als interne Kopie im Stack- Bereich (s.o.)
• Funktionsaufruf: keine Änderung/ Unterschied
• Funktionsdeklaration:

d.h. die Parameterliste

wird nicht beschrieben
 
 

• Der Rückgabetyp braucht nicht angegeben werden, sofern er nicht > sizeof( int ) ist. Fehlt der Rückgabetyp, geht der compiler davon aus, daß die Funktion int

• void gibt es in K & R noch nicht.

• Parameterliste im Funktionskopf ( formale Parameter )

Workflow

1. Idee/ Aufgabenstellung
2. Analyse der Aufgabenstellung
3. Fachkonzept

• leistungsumfang ?
• Bedienbarkeit ? ~ ca.
• Programmnavigation ? 60 %

1. DV- Konzept

• Programmorganisation ( Aufteilung in Module / Klassen )
• Aufteilung der Modle in Funktionen bzw. bei Klassen.

• Aufteiung der anstehenden Programmeirarbeit

1. Implementierung ~ 20 %
2. Test und Korrektur ~ 20 %

Anwender- Eindruck:

• Begrüßungstext
• Es können beliebig viele Spiele

• Ende

void main() Begrüßungstext / Spelregeln

{

srand(); ein Spiel internes Muster erzeugen

{

logo(); void spiel( ) Anwendereingaben entgegennehmen

for(;;) spiel(); belegen();

} versuch();

auswerten();

}

ende();

Abspann und exit(0);

globale Daten:

#define MAX 4

int pc[MAX]; Array des Rechners für 4 eindeutige Zufallszahlen aus [0...5].

int aw[MAX]; Array für einen Versuch des Anwenders.

int posok; Werden von auswerten() gesetzt positionen, die stimmen

int anzok; anzahl richtiger Werte, unabhängig von der richtigen Poition.

2 und mehrdimensionale Arrays (Matritzen)

Deklaration: int matrix [ 3 ] [ 4 ] , i , J ; i= Zeilen J= Spalten

Wichtig:

für jede Dimension beginnt der Index

mit 0 zu llaufen.

matrix [1] [2] = 439;

printf("%d", matrix [1] [2] );

scanf("%d", & matrix [1] [2]);
 
 

Syntax für den Zugriff auf eines der Arrayelemente:

Bsp.: durchlaufen des 2d- Arrays: for( i = 0 ; i < 3 ; i++ )

for( i = 0 ; i < 3 ; i++ )

{

for( j = 0; J < 4 ; j++ )

{

printf("Wert [%d] [%d] ->" ,i+1,j+1);

scanf("%d", & matrix [i] [j] );

fflush(stdin);

}

}

Anordnung im Hauptspeicher:

Die Arrayelemente liegen zeilenweise lückenlos aneinander im Hauptspeicher.

Übungsvorschlag:

1. Matrix mit Werten vollesen.
2. Spaltensummen und Zeilensummen bil-

den.
3. Ergebnisse aus 2. ausgeben.

int i = 7 ; Deklaration mit Initialisierung ----Neue Variable entsteht

char f[ ] = " Hallo " ; char *p = " Hallo" ;

Typ : char * Typ : char *

impliziter Pointer expliziter Pointer

= Konstante ! = Variable!

Sichere Variante, da Größe

Nicht mehr änderbar !!!!!
 
 
 
 

Einzelnes Arrayelement ansprechen: Typ: char

wtag[ 2 ] [ 4 ] = `X `;

putchar( wtag[ 2 ] [ 4 ] ) ;

Hinweis; greift man in ein 2d- Array mit nur einem Index zu, wird ein Zeilenanfang an-

gesprochen. Typ: Adresse hier: char *
 
 
 
 

char f[81];

typ von f : char *

typ von f[i] : char *

char wtag [7] [11] ;

Typ von wtag : char ** Zeiger auf Zeiger auf char

Typ von wtag [i]; : char * Zeiger auf char

Typ von wtag [i] [j] : char
 
 

(*) werden 2- od. mehrdimensionale Arrays bei der Deklaration gleich initialisiert, so kann in dieser Deklaration die Dimension, die ganz links steht offenbleiben.

Grund: wtag [2] [4]

solche Zugriffe gehen nur, wenn der compiler " weiß", wie lang eine Zeile ist.
 
 

argc Typ: int Anzahl der Parameter in der Kommandozeile.

Achtung: der Programmname zählt mit, gezählt wird ab 1.

ac 1 2 3 4 5 <-- argc

• prog7 /x –b 758 Hallo ¿

• argc ist immer >=1, ist argc == 1, so gibt es keine Zusatzangaben in der

diese Arrayelemente sind"Stringanfänge"
 

	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
argv [ 0 ] argv [ 1 ] argv [ 2 ] argv [ 3 ] argv [ 4 ]	D	:	\	C	\	P	R	O	G	7	.	E	X	E	Æ
	/	x	Æ
	-	b	Æ
	7	5	8	Æ
	H	a	l	l	o	Æ

putchar (argv [ 4 ] [ 3 ] ;

puts( argv [ 2 ] );

x = atoi (argv [ 3 ] ;

int char *
 
 

ANSII- C

int void main( int ac, char * av [ ], char * envp [ ] )

{

if( ac < 2 )

{

...keine Parameter...

}

return 0;

}

Einige Compiler ( zb. GNU ) erwarten

main ( ) mit Rückgabetyp int. Der Wert,

der innerhalb von main ( ) mit return

zurück gegeben wird dient als exit-code

des Programms.
 
 

Hinweis:

• für main ( ) ist noch ein dritter Parameter möglich: envp " Environment Pointer" , der den selben Datentyp wie argv hat.
• envp enthält die Ungebungsvariablen des Prozesses als Strings im ASCII- Z Format. Aufbau einer solchen Environmentvariable

Querverweis: DOS- Beispiel SET

Der letzte String aus envp ist verarbeitet, wenn envp [ i ] ein FALSE bietet.

NULL- Pointer

Praktikum: Programm, das auf einen oder mehrere der folgenden Kommandozeilenparameter in angegebener Reihenfolge reagiert.

-a -b -c -d

pprog –a –c

pprog –b

pprog –b –c –d
 
 

if ( ! strcmp (av[i], "-a" )) funk_a();

0 bei Gleichhei

• zusammengesetzter Datentyp, vom Programmierer frei zu definieren.

besseren Handhabung.

Mögliche Datentypen für Strukturkomponenten:

• Alle Grunddatentypen
• Arrays
• Pointer aller Art
• andere Strukturtypen
• nicht sich selbst

mitarbT a;

Variable a
 

	0	1									24
vname
	0	1													34
nname
	0	1					10
persnr
	0	1
gehalt

Zugriff auf die Komponenten einer Strukturvariable

1. Der Name der Strukturvariable

Benutze Punkt- Operator ·

mitarbT a;

gets( a.vname ); (vname aus Quelltext)

scanf("%f",& a.gehalt);

printf("%s %.2f\n",a.vname,a.gehalt);
 
 
 
 
 
 

Strukturen im Hauptspeicher

Die Strukturkomponenten liegen hintereinander im Hauptspeicher.

Dem Compilerhersteller ist es gestattet, Anfänge von Strukturen, aber auch einzelne Komponenten auf bestimme Adressklassen(*) auszurichten.

(*) dies kann sein:

• nächste freie Adresse ( Voreinstellung für Borland C/C++ 3.1 )
• nächste freie durch 2 teilbare Adresse
• nächste freie durch 4 teilbare Adresse
• nächste freie durch 8 teilbare Adresse
• nächste freie durch 16 teilbare Adresse

Daraus folgt:

sizeof( Struktur ) >=S sizeof ( Komponenten )

in Comilerhandbüchern und Online- Help ist dieser Sachverhalt meist beschrie-

ben unter " Aligment" oder "Strukturen".
 
 

1. ausgben( & b );

1. void einlesen( mitarbT * p )

 

 
 
 
 
 
 
 

{

printf("Vorname:-->"); gets(p-->vname);

printf("Nachname:-->"); gets(p-->nname);

printf("Pers.- Nr.:-->"); gets(p-->persnr);

scanf("Gehalt:-->"); scanf("%f",& p--> gehalt);

fflush(stdin);

}

2. void auslesen( mitarbT * p )

3. void kopieren( mitarbT * z, mitarb * q ) ; Version 1 - Komponentenweise

• verwendbar in der Systemprogrammierung und für Satzarten
• zu verstehen und zu handhaben wie Strukturen,

• Eine Union ist so groß, wie die größte ihrer Komponenten.
• Eine Union kann zeitversetzt für Daten unterschiedlichen Typs benutzt werden.
• auch möglich: die Daten, die sich in der Union befinden können in unterschied-

[0] [1] [2] [3]

l

l = 0x12345678;

Adresse z.B.: 1200 1201 1202 1203

typedef union u1s;

{

long l;

char f[4];

} u1t
 
 
 
 

• Zusammenfassung einer Menge von Daten (Anzahl Bytes ) unter einem Namen (Dateinamen).
• Dateien liegen auf einem internen Speichermedium ( Festplatte, CD, Floppy, Band;.....)
• Für die Organisation der Datenträger (--> Directories une Dateien )ist das Betriebsystem, genauer das File- system zuständig.

Grundoperationen auf Dateien und Directories:

md, cd, rd Directories

• create ( anlegen )
• open ( öffnen )
• read ( lesen )

• close ( schließen )
• rename ( umbenennen )
• unlink ( löschen )

C: Funktionen aus der Standart- bibliothek

in C gibt es seit jeher 2 Gruppen von Funktionen für die Dateizugriffe:

A.) "low level routinen"

können, bis "keine Daten mehr kommen", das Betriebssystem meldet dem

Programm dann EOF ("End of file").

--> C macht keine Annahme über den Aufbau von Dateien, noch weniger über

Sinn und Zweck der in den Dateien enthaltenen Daten.

--> Es ist Sache des Programmierers eine Datei in sinnvollen Portionen zu

lesen bzw. zu schreiben.

(byte- weise, zeilenweise, satzweise, blockweise)

--> Höher entwickelte Konzepte wie Dateizugriffsmethoden sind in C (UNIX)

nicht enthalten

zB.: ISAM " Index sequential accessing method"

So eine Datei kann sinnvoll in Portionen sizeof (Struktur) Bytes gelesen/ geschrieben werden. In diesem Fall kann der Abstand des n- ten Stzes vom Dateianfang berechnet werden:

• sequentiell

1. soll auf das Datenelement n zugegriffen werden, so müssen vorher die

 

 
 
 
 
 
 
 

n – 1 Datenelemente ( sätze) die davor stehen (über- ) lesen werden.

2. Jede Atrt Datei kann sequentiell verarbeitet werden.
3. Textdateien können nursequentiell verarbeitet werden

• direkt

Anfang n

• Direkter Zugriff ist möglich bei Dateien, die aus gleich langen Sätzen bestehen.
• Datensatz u ist
• n * sizeof( Struktur) Bytes vom Dateianfang entfernt.
• zu dieser Position kann direkt gegangen werden.
• Es kann dort Satz n gelesen werden ohne die vor diesem Satz liegenden Sätze lesen zu müssen

( wenig Daten) wird sequentiell

gelesen

• Eine Datei wird größer, wenn an ihr Ende Daten angehängt werden.
• Ein Datensatz in der Datei kann mit neuen Daten überschrieben werden. Dabei ändert sich die Größe der Datei nicht.
• Aus einer Datei kann kein Datensatz "herausgeschnitten" werden so daß sie kürzer wird.
• Sätze aus der "Mitte" einer Datei einfügen od. löschen erfordert eine Reorganisation der Datei: --> " Umkopieren "

1. Datei öffnen fopen()
2. lesen oder schreiben
3. Datei schließen fclose()

File – Pointer , Datentyp: File *

Pointer auf den Datentyp FILE, der vom Compilerhersteller in <stdio.h> vordefi-

niert ist.

typedef struct

{

-------;

-------;

} FILE;
 
 

Beim erfolgreichen öffnen einer Datei gibt fopen() einen Wert vom Typ FILE* zurück, der ungleich NULL ist. Alle weiteren Zugriffe auf die geöffnete Datei einschließlich fclose() gehen über diesen "File- Pointer",

Satzzeiger

Repräsentiert die aktuelle Schreib/Leseposition in einer geöffneten Datei.

Datentyp: long.

Der Satzzeiger enthält die aktuelle Schreib/Leseposition als ganze Zahl, es ist der Abstand zum Dateianfang in Bytes.

• Der Satzzeiger ist kein Zeiger im Sinne von Pointer, sondern eine ganze Zahl !!!
• Wichtig : jede der Schreib/Lesefunktionen bewegt den "Satzzeiger" um die

String String

FILE * fopen(char *, char *);

! = NULL,

wenn ok, im

Fehlerfall ein NULL-

pointer. sollte unbedingt

abgefragt werden

Bsp.: "TEST.DAT"

Satz in einer Binärdatei ändern (update) --> öffnen mit "rb+"

fopen() Datei öffnen

fclose() Datei schließen

int fclose( FILE *);

Hinweis: wird das Programm mit exit() beendet, so werden "vergessene"

Dateien noch korrekt geschlossen.

int fgetc(FILE *);
 
 

gelesenes Zeichen

EOF deutet auf Dateiende hin. Nur sicher bei Textverarbeitung

Bsp. Aufruf: x = fgetc(dz);

int fputc(int, FILE *);
 

Bsp. Aufruf: fputc (`a‘,dz );

fputc ( x , dz );

size_t:

je nach Implementierung (Compiler) int oder unsigned, Name des Datentyps, den sizeof() zurückgibt. (ANSI- C)

Adresse des Puffers, der die Daten aufnimmt, oft die Adresse einer Strukturvariablen.

void * ist nach ANSI- C der allgemeine Pointer. Er wird verwendet,wenn nicht

festgelegt ist, auf welche Art Daten im Einzelfall gezeigt wird.

In K&R wird als allgemeiner Pointer char * verwendet.
 
 

size_t Größe eines Datensatzes in Bytes, oft Größe einer Struktur.

Anzahl der zu lesenden Datensätze

Anzahl der tatsächlich gelesenen Sätze

size_t fwrite( void *, size_t, size_t, FILE *)

Adresse des Puffers, der die zu schreibenden Daten enthält, oft die Adresse einer Strukturvariablen.

Größe eines Datensatzes

Anzahl der zu schreibenden Datensätze.

Anzahl der tatsächlich geschriebenen Datensätze.
 

Datendateien:	Quelltexte:
KOMPO.DAT	KOMPO_L?.C
SOLI.DAT

 
 

Funktionen rund um den "Satzzeiger"

fseek(): "Satzzeiger" bewegen

int fseek(FILE *, long, int);
 

Datei
 

Anfang Ende

akt. Position

Bsp.: fseek ( dz , -sizeof ( komp_T ) , SEEK_CUR ) ;

ab akt, Position 1 Datensatz Richtung Dateianfang

rewind(): "Satzzeiger" auf Dateianfang zurück

void rewind(FILE *); Dateibezug

entspricht: fseek(dz, 0, SEEK-SET);

ftell(): "Satzzeiger" auslesen

long ftell(FILE *); Dateibezug

Bsp: Anzahl der Sätze in KOMPO.DAT ermitteln

FILE * dz;

long l,n;

dz=fopen("kompo.dat","rb");

if(!dz) { printf("Fehler.\n"); exit(!);

fseek(dz , 0 , SEEK-END);

l= ftell(dz); Dateilänge in Bytes

n=l/sizeof(kompo_T);

printf("KOMPo.DAT %ld Bytes %ld Sätze\n",l,n);

printf("Satzlgröße: %d\n", sizeof(kompo_T));

rewind(dz);
 
 

int size_t, hier unsigned

fseek(dz,(long) i*sizeof(kompo_t),SEEK_SET);

Typerzwingung

long

*sizeof(kompo_T)

long 32 bit---[2.147.483.648....+2.147.483.647]

Übungsvorschläge:

1. Für den Datenbestand SOLI.DAT Programme der Art erstellen wie für KOMPO.DAT vorhanden
2. Inhalt von KOMPO.DAT in ein ASCII- Format konvertieren, das von andeen Programmen (zb. Excel od. Informix) gelesen werden könnte.--> neue Datei

 

 
 
 
 
 
 
 

KOMPO.ASC mit fogendem Aufbau:

1 Satz pro Zeile, Trennzeichen zwischen den Datenfeldern ist:‘|‘ .

Bsp.: 5 | Beethoven | ludwig van | 1770 | 1827 |

Diese Datei nach EXCEL importieren als "DOS / OS2 Textdatei, Trennzeichen: | "

3. dto. output ist ein SQL- skript, das Sätze in eine Tabelle namens KOMPO in eine

 

 
 
 
 
 
 
 

SQL- Datenbank einfügen kann.

Bsp.: INSERT INTO KOMPO VALLUES(5,‘Beethoven‘,‘Ludwig van‘,‘1770‘,‘1827‘);

4. Pgm, mit dem ein Satz neu erfasst und an KOMPO.DAT angehängt werden kann.
5. Pgm, mit dem das Datenerement flag bei einem Datz aus KOMPO.DAT gezielt auf 0 gesetzt werden kann. = "logisches löschen".