8. Strukturen und Dateien Strukturen und Dateien
|
|
- Daniel Dieter
- vor 7 Jahren
- Abrufe
Transkript
1 Strukturen und Dateien 8-1
2 Strukturierte Datenobjekte, die in C zur Verfügung stehen, heißen Strukturen (records) und Unions Definition: Eine Struktur (struct) implementiert ein heterogenes Feld, das aus mehreren Komponeten unterschiedlicher Typen und unterschiedlicher Größe besteht. Beispiel: struct erste_struktur nr bezeichnung preis 8-2
3 Definition im Programm besteht aus der Deklaration der sog. Schablone der Struktur und der Definition von konkreten Strukturen (strukt. Variablen). Beispiel: Deklaration der Schablone der Struktur erste_struktur : struct erste_struktur { int nr; char bezeichnung[16]; double preis; Definition der Strukturen vom Typ: erste_struktur : struct erste_struktur REC1, REC2, HILF; 8-3
4 Definition kann auch gemeinsam (in einem Schritt) ausgeführt werden: struct erste_struktur { int nr; char bezeichnung[16]; double preis; REC1, REC2, HILF; Syntax der Deklaration: struct [<Name der Struktur>] { Deklaration der Komponente1; Deklaration der Komponente2;... ; 8-4
5 Strukturen können auch mit Initialisierung definiert werden: struct person { int p_zahl; char nachname[12]; char vorname[10]; int geburtsjahr;... ; struct person P1 = {2483,"MEYER","Karl",1953,, P2 = {4417,"BROD","Max",1969,, P3 = {3659,"KLANG","Ute",1978, ; 8-5
6 Zugriff zu den Komponenten 1. Punkt Notation: P1.p_zahl = 2483; strcpy(p1.nachname, "MEYER"); strcpy(p1.vorname, "Karl"); P1.geburtsjahr = 1953; Über Zeiger: struct person *pp1;... (*pp1).p_zahl = 2483; strcpy((*pp1).nachname, "MEYER");
7 3. Über Zeiger, mit -> Notation: struct person *pp1, *pp2, *pp3;... pp1->p_zahl = 2483; strcpy(pp1->nachname, "MEYER"); strcpy(pp1->vorname, "Karl"); pp1->p_zahl = 1953;... pp3->p_zahl = 3659; strcpy(pp3->nachname, "KLANG"); strcpy(pp3->nachname, "Ute"); pp3->p_zahl = 1978;
8 Verwendung von Strukturen /* Programm C13_1.c Demonstration von Strukturen */ # include <stdio.h> # include <string.h> struct person { /* Struktur deklarieren */ char name [31]; char vorname [21]; char geburtsdatum [9]; /* Format JJJJMMTT */ char geschlecht; /* W M */ unsigned int kundennummer; ; void main ( ) { struct person kunde; /* Variable definieren */ 8-8
9 strcpy ( kunde. name, "Mayerhofer" ); /* Werte zuweisen */ strcpy ( kunde. vorname, "Dietmar" ); strcpy ( kunde. geburtsdatum, " " ); kunde. geschlecht = 'M' ; kunde. kundennummer = 4711 ; printf (" \n Name : %s ", kunde. name ) ; /* Auf Struktur */ printf (" \n Vorname : %s ", kunde. vorname ); /* zugreifen */ printf (" \n Geburtsdatum: %s ", kunde. geburtsdatum ) ; printf (" \n Geschlecht : %c ", kunde. geschlecht ) ; printf (" \n Kundennummer: %i ", kunde. kundennummer ) ; printf (" \n\n " ); printf (" \n 1.Buchstaben: %c", kunde. vorname [0] ) ; printf (" %c ; ", kunde. name [0] ); printf (" Geschlecht = %s ", ( kunde. geschlecht == 'W' )? "weiblich" : "männlich") ; printf ( " \n\n " ) ; 8-9
10 /* Programm C13_1b.c Demonstration der Zuweisung von Strukturen */ # include <stdio.h> main ( ) { struct { char name [30] ; int alter ; a, b; strcpy (a. name, "Mayerhofer Kurt" ) ; a. alter = 21 ; b = a ; printf ( "\n Komponente b. name = %s ", b. name ) ; printf ( "\n Komponente b. alter = %i ", b. alter ) ; printf ( "\n\n" ) ; 8-10
11 Beispiel: Funktion für den Vertausch von Komponenten: #include <stdio.h> void tauschen (struct koor*); /* Funktions-Prototyp */ struct koor { /* Deklaration der Struktur-Schablone */ double xk; /* zwei Gleitkommakomponenten */ double yk; ; struct koor position = {12.34, 43.21; /* Definition */ void main() { printf("\nvorher %.2lf %.2lf", position.xk, position.yk); tauschen (&position); printf("\nnachher %.2lf %.2lf", position.xk,position.yk); 8-11
12 void tauschen (struct koor *werte) { double hilf; hilf = werte->xk; werte->xk = werte->yk; werte->yk = hilf; Ausgaben: Vorher Nachher
13 Merkmale des Zugriffs zu den Strukturen Verweisungen auf die Strukturen und ihre Komponenten Gegeben sei eine einfache Struktur: struct ein { int x; /* ganzzahlige Komponente */ int *y; /* Zeiger auf ganzzahl. Variable */ *P; /* Zugriff über den Zeiger P */ /* Dynamische Erzeugung der Struktur */ 8-13
14 Dann können folgende Zugriffe verwendet werden: ++P->x; /* inkrementiert x vorm Zugriff */ (++P)->x; /* inkr. P vorm Zugriff zu x */ P->x++; /* inkrementiert x nach dem Zugriff */ P++->x; /* inkr. P nach dem Zugriff zu x */ *P->y; /* liefert Inhalt des Speicher- */ /* platzes, auf den y verweist */ *P->y++; /* inkrementiert y nach dem Zugriff */ /* zum Speicherplatz, auf den y verweist */ (*P->y)++; /* inkrementiert Inhalt des Spei- */ /* cherplatzes, auf den y verweist */ *P++->y; /* inkrementiert P nach dem Zugriff */ /* zum Speicherplatz, auf den y verweist */ 8-14
15 Verwendung von typedef : Syntax: typedef <Typdefinition> <Typbezeichner> ; Beispiel:... typedef unsigned short KURZ; main() { KURZ var1 = 135;... printf("%u", var1);
16 Beispiel: Strukturen und Dateien typedef struct { /* Struktur deklarieren */ char name [31]; char vorname [21]; char geburtsdatum [9]; /* Format JJJJMMTT */ char geschlecht; /* W M */ unsigned int kundennummer; person; void main() { int i, j; person X, Y; /* Definition von zwei lokalen Strukturen */
17 Beispiel: typedef struct { int warennr; char warenname[20]; float einzelpreis;... item; void main() { item W1, W2, *pw; 8. Strukturen und Dateien... W1.warennr = 4711; strcpy (W1.warenname, "Plotter");... pw->warennr = 6552; strcpy (pw->warenname, "Drucker");
18 Unions Unions sind spezielle Formen von Strukturen Komponenten einer Union liegen übereinander, d.h. der Speicherplatz für jede Komponente der Union fängt an der gleichen Stelle (Adresse) an und immer nur eine der Komponenten kann gespeichert werden (eine momentan gespeicherte Komponente überschreibt die vorhergehende). Syntax: union [<Name der Union>] { Deklaration der Komponente1; Deklaration der Komponente2;... ; [<Name der definierten Union>]; 8-18
19 Beispiel: union { int ganzzahl; char name[10]; U1; Abspeicherung: union U1 ganzzahl name 8-19
20 Zuweisungen: strcpy (U1.name, "Schneider"); U1.ganzzahl = 1040; Inhalt der Union nach der Zuweisung strcpy (U1.name, "Schneider"); union U1 S c h n e i d e r \0 Inhalt der Union nach der Zuweisung U1.ganzzahl = 1040; union U e i d e r \0 8-20
21 Verwendung von Unions /* Programm C13_3.c - Ausgabe int in hexa (Funktion outih(x)) */ #include <stdio.h> void outih (short); /* Funktionsprototyp */ int main (void) { int eingabe; /* Variablen definieren */ char c; printf ("\n\t\t Ausgabe von INT Zahlen im Hexa-Zahlensystem"); printf ("\n\n Die integer-zahl eingeben (mit '0' beenden): "); scanf ("%i", &eingabe); /* Zahl eingeben */ while (eingabe!= 0) { printf (" Die Zahl %i ist in Hexa: ", eingabe); outih ((short)eingabe); /* Ausgabe in Hexa */ printf ("\n Die integer-zahl eingeben (mit '0' beenden):"); scanf ("%i", &eingabe); 8-21
22 printf ("\n\n"); return (0); void outih (short x) { union { unsigned short num; /* 16 bit integer */ unsigned char s[2]; /* array of hexa-characters */ val; char *p = " abcdef"; /* list of hexa-characters */ val.num = x; /* converted short value */ putchar (p[val.s[0] >> 4]); /* high byte conversion */ putchar (p[val.s[0] & 15]); putchar (p[val.s[1] >> 4]); /* low byte conversion */ putchar (p[val.s[1] & 15]); putchar ('\n'); 8-22
23 Zusammenfassung (Strukturen und Unions) Strukturen vereinfachen das Programmieren dadurch, dass sie zusammengehörenden Daten unter einem Variablennamen zusammenfassen. Strukturmitglieder (Komponenten) können nicht die Speicherklassen register, static oder void haben. Durch Zuweisung einer Struktur zu einer anderen können Arrays verdoppelt werden, was sonst nur mit der Funktion strcpy möglich ist. Strukturen können geschachtelt werden. Das heisst, in einer Struktur können wiederum andere Strukturen oder Unions erscheinen. Die Gesamtlänge einer Union ist gleich der Länge des größten Mitglieds (Komponente) dieser Union. Unions weden häufig eingesetzt, wenn innerhalb einer Struktur ein bestimmter Speicherbereich unterschiedliche Daten aufnehmen soll; diese Technik spart wertvollen Speicherplatz. 8-23
24 Dateien (Files) Datenstrukturen, die auf den externen Speichermedien gespeichert werden können. Sie ermöglichen effiziente Abspeicherung von großen Datenmengen. Sie besitzen verschiedene interne Organisationen. Sie werden mit speziellen Ein-/Ausgabeoperationen (Funktionen) behandelt: Definition der Datei Öffnen der Datei Lesen vo Daten Schreiben (Abspeichern) von Daten Schliessen der Datei 8-24
25 Vordefinerter Datentyp FILE: typedef struct { int level; /* fill/empty level of buffer */ unsigned flags; /* file status flags */ char fd; /* file descriptor */ unsigned char hold; /* ungetc char if no buffer */ int bsize; /* buffer size */ unsigned char *buffer; /* data transfer buffer */ unsigned char *curp; /* current active pointer */ unsigned istemp; /* temporary file indicator */ short token; /* used for validity checking */ FILE; /* this is the FILE object */ 8-25
26 Funktionen für die Bearbeitung von Dateien: Datei definieren: FILE *fp, *fp2, *fopen(); fp, fp2 sind Dateizeiger, über die die Dateien zugegriffen werden können fopen ist ein Prototyp der Funktion zum Öffnen der Datei Datei öffnen: <Dateizeiger> = fopen(<dateiname>, <Modus>); fp = fopen("abc.txt", "r"); fp2 = fopen("xyz.dat", "w"); Ein Zeichen von der Datei lesen: c = fgetc(fp); Modus: "r" "w" "a" 8-26
27 Ein Zeichen auf die Datei schreiben (aufzeichnen): fputc(c,fp); Ein record (struct) lesen: fscanf(<dateizeiger>, <Formatstring>, <Argumente>); fscanf(fp, "%i %s %lf", pw->nr, pw->name, pw->preis); Ein record aufzeichnen: fprintf(<dateizeiger>, <Formatstring>, <Argumente>); fprintf(fp, "%5i %s %8.2lf", pw->nr, pw->name, pw->preis); Eine Textzeile lesen: fgets(<textvariable>, <Länge>, <Dateizeiger>); fgets(pw->name, 20, fp); 8-27
28 Eine Textzeile aufzeichnen: 8. Strukturen und Dateien fputs(<textvariable>, <Dateizeiger>); fputs(pw->name, fp); Datei schliessen: fclose(fp); Beispiel: main () { FILE *datei_ptr; datei_ptr = fopen ("abc.txt", "w"); if (datei_ptr!= NULL) { fputs (pw->name, datei_ptr); fclose(datei_ptr); 8-28
29 /* Programm C11_1.c Demonstration des Kopierens einer Textdatei */ # include <stdio.h> main ( ) { char c; int count = 0; FILE *fopen ( ), *fr, *fw; fr = fopen ( "x.txt", "r" ); fw = fopen ( "y.txt", "w" ); while ( ( c = fgetc ( fr ) )!= EOF ) { count ++ ; fputc (c, fw); putchar (c); printf ("\n Insgesamt %i Zeichen wurden kopiert \n\n", count); fclose ( fr ) ; fclose ( fw ) ; 8-29
30 /* Programm C11_1a.c Demonstration des Kopierens einer Textdatei */ # include <stdio.h> main ( int argc, char *argv [ ] ) { char c; int count = 0; FILE *fopen ( ), *fr, *fw; if ( argc < 2 ) { /* ist kein Parameter vorhanden? */ printf ("\n Kein Kommandozeilen-Parameter gefunden! \n"); exit ( 1 ) ; if ( argc == 2 ) { /* nur ein Dateiname eingegeben */ printf ("\n Nur eine Datei eingegeben! \n"); exit ( 1 ) ; 8-30
31 fr = fopen ( argv [1], "r" ) ; fw = fopen ( argv [2], "w") ; while ( ( c = fgetc ( fr ) )!= EOF ) { count ++ ; fputc (c, fw); putchar (c); 8. Strukturen und Dateien printf ("\n Insgesamt %i Zeichen wurden kopiert \n\n", count); fclose ( fr ) ; fclose ( fw ) ; 8-31
32 # include <stdio.h> # include <stdlib.h> # define N 5 # define LS 5 typedef struct dat_satz { int num; char name[ls]; float e_preis; int anzahl; float ges_preis; item; int main ( void ) { int i, j; item TAB[N], BUFFER; FILE *f, *fopen ( ) ; 8-32
33 f = fopen ( "file1.dat", "r" ) ; printf ("\n Eingabe: \n"); i = 0; while (fscanf (f,"%d %s %f %d %f\n", &TAB[i].num, &TAB[i].name, &TAB[i].e_preis, &TAB[i].anzahl, &TAB[i].ges_preis)!= EOF) { i++; printf (" Der %d. Datensatz wurde eingelesen \n", i); fclose ( f ) ; f = fopen ( "file2.dat", "w" ) ; for ( i=0; i<n; i++) { fprintf ( f, "%3d ", TAB[i].num ) ; fprintf ( f, "%s ", TAB[i].name ) ; fprintf ( f, "%8.2f ", TAB[i].e_preis ) ; fprintf ( f, "%5d ", TAB[i].anzahl ) ; fprintf ( f, "%8.2f\n", TAB[i].ges_preis ) ; fclose ( f ) ;. 8-33
34 f = fopen ( "file2.dat", "r" ) ; printf ( "\n Ausgabe: \n" ) ; while ( fscanf ( f, "%d %s %f %d %f \n", &BUFFER.num, &BUFFER.name, &BUFFER.e_preis, &BUFFER.anzahl, &BUFFER.ges_preis)!= EOF) { printf (" %d ", BUFFER.num); printf (" %20s ", BUFFER.name); printf (" %8.2f ", BUFFER.e_preis); printf (" %5d ", BUFFER.anzahl); printf (" %8.2f", BUFFER.ges_preis); printf ("\n"); fclose ( f ) ; for (j = 0; j < i; j++) { printf ( "%d %s %f %d %f \n", TAB [ j ].num, TAB [ j ].name, TAB [ j ].e_preis, TAB [ j ].anzahl, TAB [ j ].ges_preis); return 0 ; 8-34
35 Bearbeitung von binären Dateien Datei definieren: FILE *fp, *fp2, *fopen(); gleich wie bei den Textdateien Datei öffnen: <Dateizeiger> = fopen(<dateiname>, <Modus>); Modus: "rb" "wb" "ab" fp = fopen("abc.dat", "rb"); fp2 = fopen("xyz.dat", "wb"); Aber: Daten lesen und speichern wir nach den binären Records, d.h. in gleicher Form, in der sie im Operationsspeicher gespeichert werden!!! 8-35
36 Dazu müssen weitere Angaben definiert und eingegeben werden. Diese Angaben sind: Länge des Record (record size) in Byte Anzahl der (gespeicherten) Records Ein record (struct) lesen: fread(<buffer-adresse>, <Record-size>, <Zahl von Records>, <Dateizeiger>); i = 0; while(n_item=fread(&tabelle[i],sizeof(tab_item),1,fp)!=0) i++; Ein record aufzeichnen: fwrite(<buffer-adresse>, <Record-size>, <Zahl von Records>, <Dateizeiger>); fwrite(tabelle, sizeof(tab_item), N, fp); 8-36
37 Beispiel: Kopieren von zwei Dateien #include <stdio.h> #define N 5 #define LS 20 typedef struct dat_satz { int num; char name[ls]; float e_preis; int anzahl; float ges_preis; item; int main (void) { int i, j, n_satz; item TAB[N], BUFFER; FILE *f, *fopen(); 8-37
38 f = fopen("file1.dat", "r"); printf ("\n Eingabe: \n"); i = 0; while (fscanf(f,"%d %s %f %d %f\n", &TAB[i].num, &TAB[i].name, &TAB[i].e_preis, &TAB[i].anzahl, &TAB[i].ges_preis)!= EOF) { i++; printf (" Der %d. Datensatz wurde eingelesen \n", i); fclose(f); f = fopen("file2.dat", "wb"); n_satz = 0; for (i=0; i<n; i++) n_satz += fwrite (&TAB[i], sizeof(item), 1, f); fclose(f); printf (" %i records wurden aufgezeichnet \n", n_satz); 8-38
39 f = fopen("file2.dat", "rb"); printf ("\n Ausgabe: \n"); while ((n_satz = fread (&BUFFER,sizeof(item),1,f))!= 0) { printf (" %d ", BUFFER.num); printf (" %-20s ", BUFFER.name); printf (" %8.2f ", BUFFER.e_preis); printf (" %5d ", BUFFER.anzahl); printf (" %8.2f", BUFFER.ges_preis); printf ("\n"); fclose(f); printf ("\n Demonstration End \n\n"); 8-39
40 Beispiel: Kopieren von zwei Dateien zweite Alternative #include <stdio.h> #define N 5 #define LS 20 typedef struct dat_satz { int num; char name[ls]; float e_preis; int anzahl; float ges_preis; item; int main (void) { int i, j, n_satz; item TAB[N], BUFFER; FILE *f, *fopen(); 8-40
41 f = fopen("bbb.txt", "r"); printf ("\n Eingabe: \n"); i = 0; while (fscanf (f,"%d %s %f %d %f\n", &TAB[i].num, &TAB[i].name, &TAB[i].e_preis, &TAB[i].anzahl, &TAB[i].ges_preis)!= EOF) { i++; printf (" Der %d. Datensatz wurde eingelesen \n", i); fclose(f); f = fopen("bbb2.dat", "wb"); n_satz = 0; for (i=0; i<n; i++) n_satz += fwrite (&TAB[i], sizeof(item), 1, f); fclose(f); printf (" %i records wurden aufgezeichnet \n", n_satz); 8-41
42 f = fopen("bbb2.dat", "rb"); printf ("\n Ausgabe: \n"); while ((n_satz = fread (&BUFFER, sizeof(item), 1, f))!= 0) { printf (" %d ", BUFFER.num); printf (" %-20s ", BUFFER.name); printf (" %8.2f ", BUFFER.e_preis); printf (" %5d ", BUFFER.anzahl); printf (" %8.2f", BUFFER.ges_preis); printf ("\n"); fclose(f); printf ("\n Demonstration End \n\n"); 8-42
43 Zusammenfassung (Dateien) Wir haben elf Funktionen kennengelernt, die der Bearbeitung von Dateien dienen. Sie stellen nur eine kleine Auswahl aus der Vielzahl der zur Verfügung stehenden Bibliotheksfunktionen dar: fopen Datei öffnen fclose Datei schliessen feof Prüfung auf Dateiende fseek Dateizeiger positionieren fgetc Einzelnes Zeichen lesen fgets Zeichenkette einlesen fputc Einzelnes Zeichen schreiben fputs Zeichenkette schreiben fscanf Daten formattiert einlesen fprintf Daten formattiert ausgeben (schreiben) remove Datei löschen 8-43
Programmiersprachen Einführung in C
Programmiersprachen Einführung in C Teil 10: Arbeiten mit Prof. Dr. Gliederung Programmiersprachen 1. Von der Maschinensprache zu C 2. Die Struktur von C-Programmen 3. Variable und Datentypen in C 4. Bildschirm
MehrDateioperationen Fachhochschule Würzburg-Schweinfurt Prof. Dr. Martin Ochs. Abspeichern und Einlesen von Texten (Strings) in Dateien
Informatik I SS 2003 Dateioperationen 1 Textdateien, Öffnen Abspeichern und Einlesen von Texten (Strings) in Dateien 1. Das Öffnen einer Datei a) Deklaration eines Zeigers auf eine Datei FILE *pfile; b)
MehrDateizugriff unter C
Begriffe Dateizugriff unter C Datei = sequentielle Ansammlung von Datenbytes, z.b. auf einer Festplatte Auch Bildschirm und Tastatur werden wie Dateien behandelt: Bildschirm ist die Datei stdout Tastatur
Mehrfile:///h:/dokumente/_fh/ ws /etinfoii/vorlesung/infoii...
7 Dateien Um Daten dauerhaft zu sichern, müssen sie auf den Sekundärspeicher (die Festplatte) abgespeichert werden. Beim Umgang mit Peripheriegeräten unter Windows und UNIX ist zu beachten Die Verbindung
MehrQuickC - Schnellkurs in C
QuickC - Schnellkurs in C Allgemeines C ist eine kurze, aber sehr mächtige Programmiersprache. Sie wurde ursprünglich dafür entwickelt, UNIX zu schreiben. Sie ist sehr hardware-nah und wird deshalb heute
MehrIm Windows Betriebssystem sind Dateien eindeutig gekennzeichnet durch ihren Pfad, Dateinamen und nach einem Punkt die Dateierweiterung.
Dateioperationen Seite 1 von 12 Im Windows Betriebssystem sind Dateien eindeutig gekennzeichnet durch ihren Pfad, Dateinamen und nach einem Punkt die Dateierweiterung. z.b.: c:\testdateien\text.dat //Datendatei
MehrArrays (Felder/Vektoren)
Arrays (Felder/Vektoren) Zusammenfassung mehrerer Variablen des gleichen Typs unter einem Namen im Speicher direkt hintereinander abgelegt Definition: Typname Arrayname [Größe]; Beispiel: int ar [5]; Zugriff
MehrVariablen. Deklaration: «Datentyp» «Variablenname» Datentyp bestimmt Größe in Bytes: sizeof Beispiel: long int v; Größe: 4 Bytes
Variablen Deklaration: «Datentyp» «Variablenname» Datentyp bestimmt Größe in Bytes: sizeof Beispiel: long int v; Größe: 4 Bytes v ist Stück im Speicher, der 4 Bytes lang ist Speicherzugriff? Über Adressen!
MehrE-/A-Funktionalität nicht Teil der Programmiersprache
C Ein-/Ausgabe C Ein-/Ausgabe C.1 Überblick E-/A-Funktionalität nicht Teil der Programmiersprache Realisisierung durch "normale" Funktionen Bestandteil der Standard-Funktionsbibliothek einfache Programmierschnittstelle
MehrGI Vektoren
Vektoren Problem: Beispiel: viele Variablen vom gleichen Typ abspeichern Text ( = viele char-variablen), Ergebnisse einer Meßreihe ( = viele int-variablen) hierfür: Vektoren ( = Arrays = Feld ) = Ansammlung
MehrZusammenfassung des Handzettels für Programmieren in C
Zusammenfassung des Handzettels für Programmieren in C In der handschriftlichen Kopie werden mehr Abkürzungen verwendet. Alles Grün markierte dient zum lernen und wird nicht auf den Handzettel übertragen.
MehrProgrammiersprachen Einführung in C
Programmiersprachen Einführung in C Teil 4: Prof. Dr. Jörg Schwenk Lehrstuhl für Netz- und Datensicherheit Gliederung Programmiersprachen 1. Von der Maschinensprache zu C 2. Die Struktur von C-Programmen
Mehr182. stdio. 183. stdio. Eingabe. Ausgabe. Typisch für Zeileneingabe und Analyse: #include <stdio.h>
182. stdio Eingabe int getchar (), getc (FILE * fp), fgetc (FILE * fp); char * gets (char * buf), * fgets (char * buf, int len, FILE * fp); int scanf (const char * fmt,...); int fscanf (FILE * fp, const
MehrInhalt. 1 Einstieg in die Welt von C Erste Schritte in C 31. Vorwort... 15
Vorwort... 15 1 Einstieg in die Welt von C 17 1.1 Die Sprache C... 17 1.2 Die C-Standardbibliothek... 18 1.3 Die nötigen Werkzeuge für C... 21 1.4 Übersetzen mit der Entwicklungsumgebung... 23 1.5 Übersetzen
Mehr6. Bearbeitung von Strings in C Bearbeitung von Strings in C
Bearbeitung von Strings in C 6-1 Definition des String: 6. Bearbeitung von Strings in C Zeichenstrings werden als Felder von Zeichen abgespeichert: char [ ] ; Wie die Daten (Zeichenfolge)
MehrProgrammieren in C. Funktionen mit Zeigern und Adressen. Prof. Dr. Nikolaus Wulff
Programmieren in C Funktionen mit Zeigern und Adressen Prof. Dr. Nikolaus Wulff ByValue versus byreferenz C übergibt immer Kopien der Variablen an Funktionen. Es ist nur dann möglich die Werte von Variablen
MehrÜbersicht. Informatik 1 Teil 9: komplexe Datentypen (Strukturen, Enumerationen, Unions)
Übersicht 9.1 Strukturen (Verwendung) 9.2 Strukturen (Typdeklaration) 9.3 Strukturen (Variablendeklaration) 9.4 Felder aus Strukturen 9.5 Zugriff auf Strukturkomponenten 9.6 Zugriff auf Strukturkomponenten
MehrOrganisatorisches. Übungsleiter: Karsten Otto Homepage: Aufgaben
Organisatorisches Übungsleiter: Karsten Otto (otto@inf.fu-berlin.de) Homepage: http://www.inf.fu-berlin.de/lehre/ss04/sysi/ Aufgaben Montags im Netz Vorbesprechung Dienstag/Mittwoch in den Übungen Abgabe
MehrPraxis der Programmierung
Zeichenketten (Strings), Ein- und Ausgabe Institut für Informatik und Computational Science Universität Potsdam Henning Bordihn Einige Folien gehen auf A. Terzibaschian zurück. 1 Zeichenketten (Strings)
MehrAlgorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Dynamische Datenobjekte Pointer/Zeiger, Verkettete Liste Eigene Typdefinitionen 1 Zeigeroperatoren & und * Ein Zeiger ist die Speicheradresse irgendeines Objektes. Eine
Mehreinlesen n > 0? Ausgabe Negative Zahl
1 Lösungen Kapitel 1 Aufgabe 1.1: Nassi-Shneiderman-Diagramm quadratzahlen Vervollständigen Sie das unten angegebene Nassi-Shneiderman-Diagramm für ein Programm, welches in einer (äußeren) Schleife Integer-Zahlen
MehrÜbersicht. Informatik 1 Teil 10 Dateien
Übersicht 10.1 Permanente Datenspeicher 10.2 Festplatte (Bild) 10.3 Dateien 10.4 Dateien öffnen 10.5 Der Filepointer 10.6 Schreiben in Dateien - die Funktion fprintf( ) 10.7 Lesen aus Dateien die Funktion
MehrFH Ravensburg-Weingarten Schriftlich Prüfung Programmieren
FH Ravensburg-Weingarten Schriftlich Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit Aufgabenblätter erreichbare Punktzahl zugelassene Hilfsmittel, 0800 1000 Uhr (120 min) 16 Seiten (einschl. Deckblatt)
MehrTeil 5: Zeiger, Felder, Zeichenketten Gliederung
Teil 5: Zeiger, Felder, Zeichenketten Gliederung Zeiger und Adressen Felder (Arrays) Zeichenketten (Strings) Zeigerarithmetik Mehrdimensionale Felder Zeiger und Adressen Felder Zeichenketten Zeigerarithmetik
MehrMusterlösung. Hochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller
Musterlösung Hochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit, 10:30 12:00 Uhr(90 min) Aufgabenblätter 14 Seiten(einschl. Deckblatt) erreichbare Punktzahl
MehrPhysische Datenstrukturen
Elementare Datentypen Strukturierte Datentypen Zeiger Seite 1 Einfache Datentypen Datentyp char Verwendung: ASCII-Zeichen Wertebereich: alle darstellbaren Zeichen, 8 bit lange Ganzzahlen im Intervall -128
MehrC- Kurs 07 Höhere Datentypen
C- Kurs 07 Höhere Datentypen Dipl.- Inf. Jörn Hoffmann jhoffmann@informa?k.uni- leipzig.de Universität Leipzig Ins?tut für Informa?k Technische Informa?k Höhere Datentypen Überblick Höhere Datentypen Werden
Mehr[Strukturen] Vereinbarung Verwendung Operationen mit struct Zeiger auf struct Strukturen auf dem Heap Datenstrukturen gebildet mit struct union
Vereinbarung Verwendung Operationen mit struct Zeiger auf struct Strukturen auf dem Heap Datenstrukturen gebildet mit struct union Vereinbarung struct name typ komponente1; typ komponente2;... typ komponenten;
MehrProgrammieren in C. Die C-Standardbibliothek: Datei Ein- und Ausgabe. Prof. Dr. Nikolaus Wulff
Programmieren in C Die C-Standardbibliothek: Datei Ein- und Ausgabe Prof. Dr. Nikolaus Wulff Das Dateisystem In C erfolgt die gesamte Ein- und Ausgabe durch Lesen oder Schreiben von Strömen (stream). Periphere
MehrInstitut für Programmierung und Reaktive Systeme. Java 2. Markus Reschke
Java 2 Markus Reschke 07.10.2014 Datentypen Was wird gespeichert? Wie wird es gespeichert? Was kann man mit Werten eines Datentyps machen (Operationen, Methoden)? Welche Werte gehören zum Datentyp? Wie
MehrTyp : void* aktuelle Parameter Pointer von beliebigem Typ
2. Funktionen - Prototypvereinbarung typangabe funktionsname(parameterliste); - Funktionsdefinition typ funktionsname(parameterliste){ Anweisung - Funktionstyp -> Typ der Funktionswertes zulaessige Typangaben
MehrGrundlagen der Programmierung in C++ Arrays und Strings, Teil 1
Grundlagen der Programmierung in C++ Arrays und Strings, Teil 1 Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Das C++ Typsystem simple structured integral enum
MehrC allgemein. C wurde unter und für Unix entwickelt. Vorläufer sind BCPL und B.
C-Crash-Kurs Eine kurze, keinesfalls erschöpfende Einführung in die Sprache C für Studierende, die eine strukturierte imperative Programmiersprache beherrschen. Die Vorstellung erfolgt am Beispiel von
MehrProgrammiersprachen Einführung in C. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm
Programmiersprachen Einführung in C Teil 2: Prof. Dr. int main (int argc, char *argv[]) int sum = 0; for (i = 0; i
MehrProgrammiertechnik. Teil 4. C++ Funktionen: Prototypen Overloading Parameter. C++ Funktionen: Eigenschaften
Programmiertechnik Teil 4 C++ Funktionen: Prototypen Overloading Parameter C++ Funktionen: Eigenschaften Funktionen (Unterprogramme, Prozeduren) fassen Folgen von Anweisungen zusammen, die immer wieder
MehrLesen Sie alle Aufgabenstellungen sorgfältig durch, bevor Sie mit der Bearbeitung der ersten Aufgabe beginnen.
INE1 Musteraufgaben für die Semesterendprüfung Hilfsmittel Vier Seiten selbst verfasste Zusammenfassung keine weiteren Hilfsmittel keine elektronischen Hilfsmittel Abgabe Füllen Sie das erste Aufgabenblatt
MehrC Überlebenstraining
C Überlebenstraining Dies ist nur ein Schnellkurs in C, der genug Einstiegswissen vermitteln soll, daß weiterführende Literatur schnell benutzt werden kann. Dies ist kein vollständiger Programmier oder
MehrInformatik I Programmieren in C
Informatik I Programmieren in C Zusammenfassung des Semesters Prof. Dr. Nikolaus Wulff Agenda Elementare Einführung C Programm Syntax Datentypen, Variablen und Konstanten Operatoren und Ausdrücke Kontrollstrukturen
MehrÜbungspaket 14 Eindimensionale Arrays
Übungspaket 14 Eindimensionale Arrays Übungsziele: Skript: Deklaration und Verwendung eindimensionaler Arrays Kapitel: 33 Semester: Wintersemester 2016/17 Betreuer: Kevin, Matthias, Thomas und Ralf Synopsis:
MehrDateien. INE2, Mittwoch / TE402 M. Thaler, Office TG208. ZHAW, M. Thaler, K. Rege, G.
Dateien INE2, Mittwoch 8.00-9.35 / TE402 M. Thaler, tham@zhaw.ch Office TG208 http://www.zhaw.ch/~tham 1 Um was gehtes? Informationsaustausch Programme tauschen Information mit Umgebung über - Kommandozeilen-Argumente
MehrFH München, FB 03 FA WS 06/07. Ingenieurinformatik. Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz
FH München, FB 03 FA WS 06/07 Ingenieurinformatik Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz Zulassung geprüft vom Aufgabensteller: Teil I Aufg. 2 Aufg. 3 Aufg. 4 Aufg. 5 Summe Note Aufgabensteller:
MehrHochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller
Hochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit, 08:00 09:30 Uhr (90 min) Aufgabenblätter 14 Seiten (einschl. Deckblatt) erreichbare Punktzahl 54 zugelassene
MehrFelder, Zeiger und Adreßrechnung
Felder, Zeiger und Adreßrechnung Felder bestehen aus Variablen eines einzigen Datentyps. Bisher kennen wir eindimensionale Felder. In C sind Felder mit beliebigen Dimensionen möglich. Unsere räumliche
MehrF Zeiger, Felder und Strukturen in C
F Zeiger, Felder und Strukturen in C F Zeiger, Felder und Strukturen in C F.1 Zeiger(-Variablen) 1 Einordnung Konstante: Bezeichnung für einen Wert a 0110 0001 Variable: Bezeichnung eines Datenobjekts
MehrErste Schritte der Programmierung in C
Erste Schritte der Programmierung in C C versus C++ Anatomie von C-Programmen für AVR- Mikrocontroller Unterschiede zwischen C++ und C 1 Grundlegende Unterschiede File-Extensions (Header und Quellcode)
MehrProgrammierkurs C++ Datenstrukturen Seite 1
Programmierkurs C++ Datenstrukturen Seite 1 3 Datenstrukturen 3.1 Arrays Zur Wiederholung als Strukturelement der Programmierung gehört auf der Seite der Datenstrukturen die Liste. Eine Liste kann auf
MehrProgrammieren in C. Speicher anfordern, Unions und Bitfelder. Prof. Dr. Nikolaus Wulff
Programmieren in C Speicher anfordern, Unions und Bitfelder Prof. Dr. Nikolaus Wulff Vergleich: Felder und Strukturen Felder müssen Elemente vom selben Typ enthalten. Strukturen können Elemente unterschiedlichen
MehrHochschule Darmstadt Informatik-Praktikum WS 2017/2018 WIng Bachelor 6. Aufgabenblatt Zeiger, verkettete Liste, Dateieingabe und -ausgabe
Aufgabe 6: Häuser verwalten - dynamisch Für ein Schneeräumungsunternehmen soll ein Programm zur Verwaltung von Häuserlisten geschrieben werden. Das Programm soll in der Lage sein, zu einem Haus die wichtigsten
MehrDr. Monika Meiler. Inhalt
Inhalt 11 Dynamische Feldvereinbarung... 11-2 11.1 Dynamische Vereinbarung von Vektoren... 11-3 11.2 Dynamische Vereinbarung von Matrizen... 11-5 11.3 Die Kommandozeile... 11-8 Propädeutikum 11-1/8 11
MehrINE1 Ein-/Ausgabe, Dateien (Files) Einführung Datenstruktur und Operationen Textdateien Binärdateien Standard Streams
INE1 Ein-/Ausgabe, Dateien (Files) Einführung Datenstruktur und Operationen Textdateien Binärdateien Standard Streams Einführung 2 von 42 Einführung Wie kann ein Programm mit seiner Umgebung Information
MehrStrukturierte Datentypen
Kapitel 10 Strukturierte Datentypen Über die normalen Datentypen hinaus gibt es in C weitere, komplexere Typen, die sich aus den einfacheren zusammensetzen. Außerdem besteht die Möglichkeit, eigene Synonyme
MehrC-Kurs 2010 Pointer. 16. September v2.7.3
C-Kurs 2010 Pointer Sebastian@Pipping.org 16. September 2010 v2.7.3 This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 License. C-Kurs Mi Konzepte, Syntax,... printf, scanf Next
MehrZeichendarstellung. Zeichen sind Zahlen (in C) Zeichen und switch
darstellung Arbeiten mit darstellung werden im Computer durch (kleine) Zahlen dargestellt in C können im Datentyp char gespeichert werden, dieser umfasst ein Byte und gilt als Ganzzahltyp darstellung Arbeiten
MehrInhalt Streams Eingabe / Ausgbe in C Dateizugriff in C Eingabe / Ausgabe in C++ Dateizugriff in C++ Error Handling
Input / Output in C, C++ Inhalt Streams Eingabe / Ausgbe in C Dateizugriff in C Eingabe / Ausgabe in C++ Dateizugriff in C++ Error Handling Page 1 Ausgaben in C,C++ - generell Fuer C basierte Ausgaben:
MehrLösungen der P1-Musterprüfungsaufgaben
Lösungen der P1-Musterprüfungsaufgaben 7.6.2012 Textformatierung Eine Textdatei wird eingelesen, aufeinander folgende White-space-Zeichen werden zu einem zusammengefasst, die Zeilenlänge wird angepasst
MehrGrundlagen der Informatik 6. Arrays I
6. Arrays I Motivation Array (konstante Länge) Speicherbereich Eingabe von Arrays Grundlagen der Informatik (Alex Rempel) 1 Motivation Beispiel: Bildschirmpixel zeichnen Auflösung 800x600, d.h. insgesamt
MehrDeklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
MehrGrundlagen und Konzepte von C Datenstrukturen
Grundlagen und Konzepte von C Datenstrukturen Ausarbeitung von Andreas Gadelmaier Proseminar C Grundlagen und Konzepte Arbeitsbereich Wissenschaftliches Rechnen Fachbereich Informatik Fakultät für Mathematik,
MehrBetriebssysteme, Rechnernetze und verteilte Systeme 1. Crashkurs C (2)
Betriebssysteme, Rechnernetze und verteilte Systeme 1 Crashkurs C (2) Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/
MehrC/C++-Programmierung
1 C/C++-Programmierung Speicherverwaltung, 0, const Sebastian Hack Christoph Mallon (hack mallon)@cs.uni-sb.de Fachbereich Informatik Universität des Saarlandes Wintersemester 2009/2010 2 Speicherverwaltung
Mehr6. Zeiger Allgemeines Definition eines Zeigers
6. Zeiger www.c-programme.de Stefan Thiemert Kapitel 6 - Seite 1 von 6 6. 1. Allgemeines Zeiger spielen in der Programmierung eine wichtige Rolle. Sie sind wichtig, bei der Arbeit mit Arrays und Funktionen.
MehrFakultät Angewandte Informatik Lehrprofessur für Informatik 23.01.2012
WS 2011/2012 Fakultät Angewandte Informatik Lehrprofessur für Informatik 23.01.2012 Prof. Dr. Robert Lorenz Musterlösung zur Vorlesung Informatik I, Extrablatt zu komplexen Datenstrukturen Aufgabe 45 **
MehrHochschule Darmstadt Informatik-Praktikum (INF 1) WS 2014/2015 Wirtschaftsingenieur Bachelor 4. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für ein Baumkataster sollen für maximal 500 Bäume Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Nummer Bauminfo Baumart Hoehe Baum Umfang
MehrDateien lesen und schreiben mit php
Dateien lesen und schreiben mit php (fopen(), fgets(), fread(), fwrite, fclose(), fputs(), file_get_contents()) Der Dateizugriff (anfügen und lesen) fopen(filename, mode) Öffnen vom lokalen Dateisystem
Mehr2. Aufgabe (3 Punkte) Ergänzen Sie die leeren Zellen derart, dass sich in einer Zeile die selben Zahlenwerte ergeben.
Programmieren bei Dr. Robert Heß TM&M1, IST1 und ET1 Ende SS 2003 Klausur 1. Aufgabe (2 Punkte) Kodieren Sie folgende Dezimalzahlen in Binärzahlen um. Zeigen Sie den Rechenweg, die negative Zahl soll im
MehrC kompakt für Java-Programmierer
C kompakt für Java-Programmierer Prof. Dr. Carsten Vogt, FH Köln, Institut für Nachrichtentechnik, www.nt.fh-koeln.de/vogt/ Stand: Februar 2012 In der Übung und im Praktikum "Betriebssysteme und verteilte
MehrZusammengehörige Daten struct. Strukturierte Datentypen und Funktionszeiger. Zugriff auf struct-elemente. Variablendeklarationen mit struct
Zusammengehörige Daten Anstatt logisch zusammengehörende Daten in mehreren unabhängigen Variablen zu speichern, kann man für sie einen eigenen Datentyp ( Verbund, Record ) definieren, der diesen Zusammenhang
Mehr7 Funktionen. 7.1 Definition. Prototyp-Syntax: {Speicherklasse} {Typ} Name ({formale Parameter});
S. d. I.: Programieren in C Folie 7-1 7 Funktionen 7.1 Definition Prototyp-Syntax: Speicherklasse Typ Name (formale Parameter); der Funktions-Prototyp deklariert eine Funktion, d.h. er enthält noch nicht
MehrHochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller
Hochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit, 10:30 12:00 Uhr(90 min) Aufgabenblätter 15 Seiten(einschl. Deckblatt) erreichbare Punktzahl 61 zugelassene
MehrFile I/O. Persistieren von Daten. Gastvorlesung Ralph Erdt erdt (bei) informatik.fh-wiesbaden.de
File I/O, Ralph Erdt, erdt (bei) informatik.fh-wiesbaden.de Seite 1 File I/O Persistieren von Daten Gastvorlesung - 18.01.10 Ralph Erdt erdt (bei) informatik.fh-wiesbaden.de File I/O, Ralph Erdt, erdt
MehrÜbungspaket 29 Dynamische Speicherverwaltung: malloc() und free()
Übungspaket 29 Dynamische Speicherverwaltung malloc() und free() Übungsziele Skript In diesem Übungspaket üben wir das dynamische Alloziieren 1. und Freigeben von Speicherbereichen 2. von Zeichenketten
MehrGrundlagen. Die Komponenten eines C Programms. Das erste Programm
Grundlagen 1. Die Komponenten eines C Programms 2. Ein Programm erzeugen und übersetzen 3. Variablen Deklarieren und Werte zuweisen 4. Zahlen eingeben mit der Tastatur 5. Arithmetische Ausdrücke und Berechnungen
MehrEinführung in die Programmiersprache C
Einführung in die Programmiersprache C Marcel Arndt arndt@ins.uni-bonn.de Institut für Numerische Simulation Universität Bonn Der Anfang Ein einfaches Programm, das Hello World! ausgibt: #include
MehrModellierung und Programmierung
Modellierung und Programmierung Dr. Martin Riplinger 9.1.2013 IAM Institut für Angewandte Mathematik Fortgeschrittene Ein- und Ausgabe Bisher: Ein- und Ausgabe nur über die Kommandozeile Erweiterung: Konzept
MehrProgrammierung mit C Zeiger
Programmierung mit C Zeiger Zeiger (Pointer)... ist eine Variable, die die Adresse eines Speicherbereichs enthält. Der Speicherbereich kann... kann den Wert einer Variablen enthalten oder... dynamisch
MehrEin- und Ausgabe mit Dateien
Ein- und Ausgabe mit Dateien Edouard Lamboray Informatik I für D-ITET (2004) Ein- und Ausgabekonzepte in C und C++ fstream header Streamobjekt Files schreiben und lesen Argumente von main Vorbemerkungen
MehrProgrammieren in C. Eine Einführung in die Programmiersprache C. Prof. Dr. Nikolaus Wulff
Programmieren in C Eine Einführung in die Programmiersprache C Prof. Dr. Nikolaus Wulff Textausgabe per printf Die Funktion printf ist kein Bestandteil der C Sprache sondern gehört zur C Bibliothek. printf
MehrPass by Value Pass by Reference Defaults, Overloading, variable Parameteranzahl
Funktionen Zusammenfassung von Befehlssequenzen als aufrufbare/wiederverwendbare Funktionen in einem Programmblock mit festgelegter Schnittstelle (Signatur) Derartige prozedurale Programmierung erlaubt
Mehr3. Einführung in C Programmierung Einführung in C Programmierung
Einführung in C Programmierung 3-1 Warum die Programmiersprache C lernen? C Programme sind leicht zwischen verschiedenen Systemumgebungen portierbar. C ist eine geeignete Sprache zum Aufbau einer Programmbausteinbibliothek.
Mehrstructure-type-specifier struct [ identifier ] { struct-declaration-list } struct identifier struct-declaration-list struct-declaration
Verbundtypen structure-type-specifier struct [ identifier ] { struct-declaration-list } struct identifier struct-declaration-list struct-declaration struct-declaration-list struct-declaration struct-declaration
MehrFILE *fp; char fname[100];... fp = fopen (fname, rb ); if( fp == NULL ) { perror( fopen );... } // Fehlernachricht auf letzten Fehler, der aufkam
Aktuelle Fileposition ermitteln long pos; pos=ftell(fp); //aktuelle Bytenummer Filelaenge in Bytes fseek(fp,0,seek_end); pos=ftell(fp); Fileendeerkennung int rc; rc = feof (fp) //!= 0 bei Fileende // ==
MehrElementare Datentypen in C++
Elementare Datentypen in C++ bool signed/unsigned char signed/unsigned short int signed/unsigned int signed/unsigned long int (signed/unsigned long long int) float double long double void enum char Der
MehrVORLESUNGSUNTERLAGEN ZU PROGRAMMIEREN 2
STUDIENGANG ANGEWANDTE INFORMATIK STUDIENGANG INFORMATIONS- UND KOMMUNIKATIONSTECHNIK VORLESUNGSUNTERLAGEN ZU PROGRAMMIEREN 2 Grundlagen der Programmierung und Einführung in die Sprache C Prof. Dr.-Ing.
MehrZeichenketten (1) Literale von Zeichenketten werden in doppelte Anführungszeichen gesetzt
Zeichenketten (1) Literale Literale von Zeichenketten werden in doppelte Anführungszeichen gesetzt "Hallo Welt" Mehrere solcher Literale gelten als eine Zeichenkette, wenn sie nur durch Whitespaces (Leerzeichen,
MehrEinstieg in die Informatik mit Java
1 / 27 Einstieg in die Informatik mit Java Klassen als Datenstrukturen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 27 1 Überblick: Klassen als Datenstruktur 2 Vereinbarung
MehrTestklausur zur Vorlesung. Programmieren in C
Studienfach: Semester: Testklausur zur Vorlesung Programmieren in C Prof. Dr. Nikolaus Wulff WS/SS 2004/05 Juni 2005 Diese Klausur besteht aus fünf n, von denen Sie drei bearbeiten und lösen müssen, d.h.
MehrEine Mini-Shell als Literate Program
Eine Mini-Shell als Literate Program Hans-Georg Eßer 16.10.2013 Inhaltsverzeichnis 1 Eine Mini-Shell 1 1.1 Einen Befehl parsen......................... 2 1.2 Was tun mit dem Kommando?...................
MehrDr. Monika Meiler. Inhalt
Inhalt 3 C-Ausdrücke...3-2 3.1 Arithmetische Ausdrücke...3-3 3.2 Wertzuweisungen...3-5 3.3 Inkrementieren und Dekrementieren...3-6 3.4 Logische Ausdrücke (Bedingungen)...3-7 3.5 Bedingte Ausdrücke...3-8
MehrC- Kurs 03 Ausdrücke und Operatoren
C- Kurs 03 Ausdrücke und Operatoren Dipl.- Inf. Jörn Hoffmann jhoffmann@informadk.uni- leipzig.de Universität Leipzig InsDtut für InformaDk Technische InformaDk Ausdrücke Institut für Informatik Ausdrücke
Mehr2. Programmierung in C
2. Programmierung in C Inhalt: Überblick über Programmiersprachen, Allgemeines zur Sprache C C: Basisdatentypen, Variablen, Konstanten, Operatoren und Ausdrücke Anweisungen und Kontrollstrukturen (Steuerfluss)
MehrInteger Integer Integer (Voreinstellung) Integer Gleitkomma Gleitkomma leer/unbestimmt Integer ohne Vorzeichen Integer (explizit) mit Vorzeichen
1 C-Schlüsselwörter Schlüsselwörter sind in allen Programmiersprachen reservierte Wörter. In C sind auch alle Namen _[A-Z]... und... reserviert, auch _... bereichsweise. Weiterhin durch die Standard-
MehrEinführung in die C-Programmierung
Einführung in die C-Programmierung Warum C? Sehr stark verbreitet (Praxisnähe) Höhere Programmiersprache Objektorientierte Erweiterung: C++ Aber auch hardwarenahe Programmierung möglich (z.b. Mikrokontroller).
Mehr4. Einfache Programmstrukturen in C Einfache Programmstrukturen in C
Einfache Programmstrukturen in C 4-1 Welche einfache Programmstrukturen sind zu unterscheiden? Arithmetische und logische Ausdrücke und Zuweisungen Verzweigungen Unvollständige bedingte Anweisungen Vollständige
MehrStrukturierte Datentypen (struct) 2006 Pearson Education, Inc. All rights reserved.
1 8 Strukturierte Datentypen (struct) 2 8.1 Einführung 8.2 Definition von Strukturen 8.2.1 Selbstbezügliche Strukturen 8.2.2 Definition von Variablen strukturierter Datentypen 8.2.3 Bezeichner für Strukturen
MehrStrukturen können wie normale Variablen an Funktionen übergeben werden. Strukturen können auch Ergebnis einer Funktion sein
19 Strukturen 19.2Strukturen als Funktionsparameter 19.2 Strukturen als Funktionsparameter Strukturen können wie normale Variablen an Funktionen übergeben werden Übergabesemantik: call by value Funktion
MehrAdvanced Programming in C
Advanced Programming in C Pointer und Listen Institut für Numerische Simulation Rheinische Friedrich-Wilhelms-Universität Bonn Oktober 2013 Überblick 1 Variablen vs. Pointer - Statischer und dynamischer
MehrPhysische Dateistrukturen
Direktzugriffsdateien Seite 1 Charakteristik: Folge von Elementen (physischen Datensätzen) Länge (Speicherbedarf) dynamisch Begriffe: x = < > leere Datei x x = Datei x mit einem Datensatz x1 x =
MehrII. Grundlagen der Programmierung. Beispiel: Merge Sort. Beispiel: Merge Sort (Forts. ) Beispiel: Merge Sort (Forts. )
Technische Informatik für Ingenieure (TIfI) WS 2006/2007, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Rekursion Datenstrukturen Merge S ( split, s, merge ) Beispiel:
MehrC- Kurs 08 Zeiger. Dipl.- Inf. Jörn Hoffmann leipzig.de. Universität Leipzig Ins?tut für Informa?k Technische Informa?
C- Kurs 08 Dipl.- Inf. Jörn Hoffmann jhoffmann@informa?k.uni- leipzig.de Universität Leipzig Ins?tut für Informa?k Technische Informa?k Überblick Datentyp zur Verwaltung von Adressen (auf Speicherplätze)
MehrDynamischer Speicher
Dynamischer Speicher C-Kurs 2012, 3. Vorlesung Tino Kutschbach tino.kutschbach@campus.tu-berlin.de http://wiki.freitagsrunde.org 13. September 2012 This work is licensed under the Creative Commons Attribution-ShareAlike
Mehr