Inhalt. 4.8 Strukturen in C

Transkript

1 Inhalt Inhalt: 4. Programmiersprache C 4.1 Programmaufbau in C 4.2 Basisdatentypen und einfache Anweisungen 4.3 Steuerfluss-Konstrukte 4.4 Arbeit mit indizierten Größen (Felder) 4.5 Arbeit mit Pointern 4.6 Arbeit mit Zeichenketten 4.7 Funktionen 4.8 Strukturen R. Großmann, Strukturen in C Aus C-Sicht stellen Strukturen eine Zusammenfassung von Datenelementen unterschiedlichen Typs unter einem Namen dar. Strukturen sind aus C++ Sicht Klassen (Typen) deren Elemente öffentlich (public) sind. Dadurch sind sie vergleichbar mit Feldern, die eine Zusammenfassung (Reihung) von Datenelementen gleichen Typs unter einem Namen darstellen. Der Zugriff auf Datenelemente ist allerdings unterschiedlich: bei Feldern über den Index hinter dem Feldnamen, z.b. feld[i] bei Strukturen durch den Datenelementnamen hinter dem Strukturnamen und einem Punkt (. ), z.b. Person.Name 132

2 Aufbau und Deklaration einer Struktur Person Name Vorname Geschlecht Gehalt struct Person { char Name[30]; ; char Vorname[30]; int Geschlecht; float Gehalt; Person ist der Strukturname (und damit wie ein Typ) und Name, Vorname,... sind Komponentennamen. 133 Aufbau und Deklaration einer Struktur (1) Deklaration von Struktur-Variablen Da die Deklaration einer Struktur wie eine Typdefinition wirkt, können Variable diesen Strukturtyps folglich unter Nennung von struct Strukturname deklariert werden. Beispiel: struct Person {...; struct Person p1,p2; Es wäre auch eine Kombination möglich: struct Person {... p1,p2; 134

3 Aufbau und Deklaration einer Struktur (2) Deklaration von Struktur-Variablen mittels Typ- Definition typedef struct Person {... person_t; person_t p1,p2; Ein per typdef geschaffener Typ kann wie ein Standarddatentyp (int, float, usw.) zur Deklaration von Variablen und zur Deklaration weiterer Strukturen benutzt werden Wertebelegung von Strukturvariablen Wertebelegung von Struktur-Variablen: Eine Möglichkeit besteht in der Initialisierung bei der Deklaration: Beispiel: struct Person p1={"krause","jens",1, , p2={"meier","ines",0, ; oder es erfolgt eine Wertezuweisung an die Komponenten: strcpy( p1.name, "Krause" ); p1.gehalt = ; 136

4 6.3 Schachtelung von Strukturen Strukturen können wieder Strukturen enthalten Beispiel: struct Datum { int tag; char monat[10]; int jahr; ; struct Person { char name[30]; char vorname[20]; struct Datum beginn; // Struktur in Struktur int geschlecht; ; 137 Schachtelung von Strukturen Die Schachtelung darf aber nur in der angegebenen Weise erfolgen, d.h. man darf eine Struktur-Deklaration nicht direkt in eine weitere Struktur aufnehmen, sondern ausschließlich über eine Strukturvariable. Zugriff auf geschachtelte Strukturen: z.b.: struct person p1; und person enthält die geschachtelte Struktur struct datum beginn; p1.name aber p1.beginn.monat 138

5 Felder von Strukturen Strukturen können als Elemente in Feldern gereiht werden Beispiel: struct Person { char name[30]; char vorname[20]; struct Datum beginn; int geschlecht; ; struct Person mitarbeiter [5] ; Zugriff: mitarbeiter[1].name mitarbeiter[1].beginn.monat 139 Ein Beispiel mit Strukturen (1) Auf Übungsblatt 5, Teilaufgabe 3 (für allg. Maschinenbau) sind Messwerte und Orte im Speicher zu organisieren, zu sortieren und auszugeben. Bislang hatten wir zwei unabhängige Felder benutzt: float werte[max_werte]; char orte[max_werte] [MAX_STRLEN]; Hier bietet sich an, Wert und Ort in einer Struktur zusammenzufassen. struct messung { float wert; char ort[max_strlen]; ; struct messung m[max_werte]; // Feld struct messung zws_messung; // Zwischenspeicher für Tausch 140

6 Ein Beispiel mit Strukturen (2) i=0; ende=0; n_werte=0; while(!ende) { if (i<max_werte) { printf("eingabe Messwert Ort [%d]:",i); gets(eingabestring); sscanf(eingabestring,"%f", &m[i].wert); if (m[i].wert==999.0) ende=1; else { sscanf(eingabestring,"%s",dummystring); strcpy( m[i].ort, &eingabestring[strlen(dummystring)]); i = i + 1; n_werte ++; else // Gesamtanzahl der Messwerte erreicht ende = 1; 141 Ein Beispiel mit Strukturen (3) Zuweisung von Strukturen, hier im Kontext des Tauschs der Elemente. if (tausch) { // Umspeichern der Strukturen zws_messung = m[i]; m[i] = m[i+1]; m[i+1] = zws_messung; Eine Zuweisung von Strukturvariable beinhaltet das Kopieren aller Komponenten auf die Zielstruktur. Hier werden auch die Zeichenketten kopiert. 142

7 Zuweisen, Kopieren von Strukturvariablen Bei der Zuweisung von Strukturen a = b werden immer alle Elemente von b nach a kopiert. Das ist gleichbedeutend mit Kopieren der Speicherinhalte, die eine Strukturvariable einnimmt. Die Länge einer Struktur (hier kann der Typ oder die Strukturvariable benutzt werden) wird mit dem Operator size_t sizeof (strukturname); ermittelt. Vor dem C99-Standard wurde die Größe noch zur Übersetzungszeit ins Programm eingesetzt. Spätere Compiler erlauben, die Größe dynamisch zur Laufzeit zu bestimmen. 143 sizeof - Operator size_t sizeof (name); wobei name eine Variable, eine Struktur, ein Typ oder eine Feld sein kann. Namen für Felder werden hier aber nicht wie die Anfangsadresse auf das erste Element gewertet, sondern stehen für den Gesamtspeicherplatz des Feldes. Beispiele: #define MAX_STRLEN 120 struct messung { float wert; char ort[max_strlen]; ; struct messung mvar, m[10]; int l1 = sizeof(messung); // ergibt 124 int l2 = sizeof(mvar); // ergibt auch 124 int l3 = sizeof(m); // ergibt

8 Zeiger auf Strukturen (1) Es können Zeiger auf Strukturen erklärt werden Beispiel: struct datum { int tag; char monat[10]; int jahr; d1,d2; struct datum *zeig; zeiger = &d1; // Adresse der Strukturvariablen d1 (*zeiger).tag //Zugriff auf Komponente zeiger->tag //Zugriff auf Komponente beide Schreibweisen sind identisch! 145 Zeiger auf Strukturen (2) Das Kopieren von Strukturen, ausgehend von Zeigern: Beispiel: struct datum { int tag; char monat[10]; int jahr; d1,d2; datum *zeiger1 = &d1; // Adresse der Strukturvariablen d1 datum *zeiger2 = &d2; // Adresse d2 (*zeiger2) = (*zeiger1); // ist eine Möglichkeit memcpy(zeiger2,zeiger1,sizeof(datum)); // die andere Möglichkeit 146

9 Zeiger auf Strukturen an Funktionen übergeben Es können Zeiger auf Strukturen als Parameter von Funktionen auftreten. Beispiel: struct datum { int tag; char monat[10]; int jahr; d[5]={{7, April,1981,{12, Juni,1979, {20, Mai,1980,{4, Juni,1974,{0,,0; int finde(int j,struct datum *p) { int i=0; while ((p->tag)!=0){if ((p->jahr)==j) return (p->tag);else p++;; return 0; Aufruf: finde(1980,d); 147 Inhalt Inhalt: 4. Programmiersprache C 4.1 Programmaufbau in C 4.2 Basisdatentypen und einfache Anweisungen 4.3 Steuerfluss-Konstrukte 4.4 Arbeit mit indizierten Größen (Felder) 4.5 Arbeit mit Pointern 4.6 Arbeit mit Zeichenketten 4.7 Funktionen 4.8 Strukturen 4.9 Typen, Variable und Konstante R. Großmann, 148

10 4.9 Typen, Variable und Konstante Überblick: Gültigkeitsbereiche von Variablen, Sichtbarkeit Speicherklassen Type-Umwandlungen durch Typecasts Präprozessorkonstanten und Makro-Funktionen durch #define 149 Gültigkeitsbereiche (1) Variablen können verschiedene Gültigkeitsbereiche besitzen: lokale Gültigkeit und globale Gültigkeit Lokale Gültigkeit Variablen können nur in der Funktion benutzt werden, in der sie deklariert werden. Eine lokale Gültigkeit kann auf die main-funktion, aber auf jede andere Funktion, oder auch auf Verbundanweisungen bezogen sein. Lokale Gültigkeit innerhalb der main()-funktion: Die Variablen sind nur innerhalb der main-funktion sichtbar. Andere Funktionen (Prozeduren) können nicht direkt auf diese Variablen zugreifen. Bei Bedarf muss der Wert der Variablen den Funktionen über Parameter vermittelt werden. 150

11 Gültigkeitsbereiche (2) Beispiel zur lokalen Gültigkeit innerhalb der main()-funktion: int berechne(int arg) { // b, c sind hier nicht sichtbar, a wird über arg vermittelt return arg*2; main() { int a, b, c; b = berechne(a); 151 Gültigkeitsbereiche (3) lokale Gültigkeit in einer Funktion (Prozedur): Nur der Code innerhalb der Funktion kann diese Variable benutzen. Wird aus der Funktion zurückgesprungen, sind die Variablen nicht mehr sichtbar. Ihr Speicherplatz wird freigegeben und für andere Zwecke verwendet. double fakultaet(int arg) { double f=1.0; int i; // ist nur lokal gültig if (arg<2) return 1.0; for (i=2;i<=arg;i++) f = f * (double)i; return f; main() { double y = fakultaet(42); printf( %lf, y); printf( %d,i); // Fehler: i ist hier nicht sichtbar 152

12 Gültigkeitsbereiche (4) lokale Gültigkeit in einer Funktion (Prozedur) Achtung: Bei mehrmaligem Aufruf einer Funktion bleibt der Wert einer lokalen Variablen i.a. nicht gespeichert (Ausnahme durch spezielle Speicherklasse). Die Variable verliert zwischenzeitlich ihre Gültigkeit und wird bei jedem neuen Eintritt in die Funktion neu erzeugt. Sichtbarkeit und Überdeckung lokaler Variable: void f1(int *a) { int x=5; *a = *a+f2(&x); void f2(int *a) { int x=77; *a = *a+x; Die Variable x in f2 überdeckt x aus f1. Innerhalb f2 wird mit dem Wert x=77 gearbeitet. Die Variable x innerhalb f1 bleibt bestehen, ist aber nicht sichtbar, wenn f2 abgearbeitet wird 153 Gültigkeitsbereiche (5) Globale Gültigkeit: Globale Variablen sind über alle Funktionen hinweg gültig. Eine Ausnahme ist die lokale Überdeckung durch gleich benannte Variablen in Funktionen oder Verbundanweisungen. Durch globale Variable können Daten zu und von Funktionen vermittelt werden: Vorteile: bequem für Programmierer; schnell, da kein Kopieraufwand bei Aufruf der Funktion Nachteil: Die Funktionsdeklaration enthält keine Information, welche globalen Daten zur Eingabe und/oder Ausgabe benutzt werden. Man verliert schnell den Überblick und kann nicht mehr einschätzen, ob der Aufruf von Funktionen eventuell unerwünschte Nebenwirkungen hat. Globale Variablen sehr sparsam verwenden! 154

13 Beispiel für globale Gültigkeit: Gültigkeitsbereiche (6) int vermoegen=0; // globale Variable void erbschaft( int betrag) { vermoegen = vermoegen + betrag; zahle_erb_steuer(betrag); void zahle_erb_steuer(int erb_betrag) { vermoegen = vermoegen (int)( (float)erb_betrag * (float) E_STEUERSATZ/100.0); main() {... vermoegen = X; erbschaft(y); if (vermoegen >= ) printf( Ich bin reich! \n ); 155 Speicherklassen (1) C besitzt vier Schlüsselworte, um die Speicherklasse von Variablen zu definieren. Sie teilen dem Übersetzer mit, wie eine Variable zu speichern ist. auto Standard für lokale Variablen register wie auto, Variable wird vorrangig in einem Prozessorregister gespeichert (anstatt im Hauptspeicher) auto und register nur für lokale Variablen static Variable behält den Wert auch zwischen Funktionsaufrufen extern Variable ist bereits an anderer Stelle deklariert und soll nur als Bezeichner noch einmal eingeführt werden sinnvoll bei mehreren Quelletextdateien. 156

14 Speicherklassen (2) Beispiel für static: int zaehlen() { static int zahl=0; zahl++; return zahl; main() { int x, ergebnis; for ( x=1;x<47;x++) ergebnis = zaehlen(); printf( Das Ergebnis lautet %d\n, ergebnis); 157 Typecasts Der Übersetzer wandelt Typen von einem in einen anderen um, wenn es notwendig wird. In einigen Fällen werden Warnungen generiert, falls es zu Genauigkeitsverlust kommt oder Zuweisungen mit unterschiedlichem Wertebereich angewiesen werden. Man kann durch Typcasts aber auch eine Typumwandlung explizit anweisen. Typischer Fall: int a=3,b=5; float x_verhaeltnis_ab = a/b; // ergibt Warnung und Ergebnis 0 float y_verhaeltnis_ab = (float) a/b; // ergibt Ergebnis 0.0 float z_verhaeltnis_ab = (float) a/(float) b; // ergibt

15 Präprozessor-Konstanten (1) Für Parameter, die zur Übersetzungszeit festgelegt werden, bieten sich Präprozessorkonstanten an. Allgemeine Form: #define NAME WERT NAME ist der Konstantenname, der im Programm benutzt wird WERT ist dabei eine Zeichenkette, die aber auch einen Zahlenwert repräsentieren kann. Vor den eigentlichen Übersetzen wertet der Präprozessor die #define Anweisungen aus, und setzt überall dort, wo NAME als Bezeichner im Quellcode steht, die Zeichenkette WERT ein 159 Präprozessor-Konstanten (2) Beispiel: //#define STADT Dresden #define STADT Cuxhafen #define STEUERSATZ 19 #define PI //#define BEGRUESS_STRING Sehr geehrtes Publikum #define BEGRUESS_STRING Liebe Seeleute und Sportschiffer //#define BEGRUESS_STRING Liebe Parteigenossen #define RICHTUNG gesenkt //#define RICHTUNG erhoeht printf( %s, unabhaengig von der Zahl Pi mit dem Wert %f gilt in %s ein Steuersatz von %d Prozent.\n, BEGRUESS_STRING,PI,STADT,STEURSATZ); printf( Wir stehen dafuer, dass der Steuersatz in %s %s wird!\n, STADT, RICHTUNG); 160

16 Präprozessor-Konstanten (3) Beispiel: Maximale Anzahl von Pixeln in einem Bild #define MAX_HORIZ 4000 #define MAX_VERT 4000 struct { char r,g,b; pixel; pixel bild[max_vert][max_horiz]; for(int v=0;v<max_vert;v++) for(int h=0;h<max_horiz;h++) bild[v][h] = ; 161 Präprozessor-Makros (1) Der Präprozessor kann auch kleine Makro-Funktionen mit Parametern in dem Code ersetzen. #define ABS(x) ((x)<0?-(x):(x)). float a,b; int x,y;. b = ABS(a); // wird ersetzt durch: b = a<0?-a:a; y = ABS(x); // wird ersetzt durch: y = x<0?-x:x; Vorteil: Man kann Details in Funktionen verbergen. Der Aufwand eines Funktionsaufrufs wird aber zur Laufzeit vermieden. Programme laufen dadurch schneller! 162

17 Präprozessor-Makros (2) Unterschied Makros gegenüber echten C-Funktionen: Makro-Funktionen werden durch Ersetzung im Quelltext realisiert. C-Funktionen werden zur Laufzeit aufgerufen und als ganzes ausgeführt. Wenn Operationen innerhalb und außerhalb der Makros/Funktionen verschiedene Prioritäten aufweisen, kann sich ein unterschiedliches Verhalten ergeben, je nachdem ob man eine Makro-Funktion oder eine echte C-Funktion benutzt. Beispiel: #define F(x,y) (x)+(y) a=1; b=2; c=3; int f(int x, int y) { return x+y; a=1; b=2; c=3; d=f(a,b)*c; // d = a+b*c; // d = 1+2*3 = d1=f(a,b)*c; // f(1,2) = 3 // d = 3* c = 9 163