Strukturierte Datentypen (struct) 2006 Pearson Education, Inc. All rights reserved.

Transkript

1 1 8 Strukturierte Datentypen (struct)

2 2 8.1 Einführung 8.2 Definition von Strukturen Selbstbezügliche Strukturen Definition von Variablen strukturierter Datentypen Bezeichner für Strukturen Operationen auf Strukturen 8.3 Initialisierung von Strukturen 8.4 Zugriff auf Elemente von Strukturen 8.5 Strukturen und Funktionen 8.6 typedef 8.7 Fallstudie: Verbesserte Kartenmisch- und Gebesimulation

3 3 8.1 Einführung Strukturen (oder strukturierte Datentypen ) Zusammenfassung von Variablen, die in einer Beziehung zueinander stehen, unter einem gemeinsamen Namen Dadurch wird eine Art neuer Datentyp definiert. Strukturen können Variablen vieler verschiedener Datentypen enthalten im Gegensatz zu Arrays, die nur Elemente des gleichen Datentyps enthalten. Strukturen werden für die Definition von Records, die in Dateien gespeichert werden, benutzt (s. Kapitel 9). Mit Hilfe von Zeigern und Strukturen können komplexere Datenstrukturen wie verkettete Listen, Warteschlangen, Stapel und Bäume aufgebaut werden.

4 8.2 Definition von Strukturen 4 Strukturen sind abgeleitete Datentypen sie werden aus Objekten anderer Datentypen konstruiert. Definition einer Struktur: struct card { char* face; char* suit; }; Das Schlüsselwort struct definiert die Struktur. Der Bezeichner card ist der Struktur-Bezeichner, der die Struktur benennt und zusammen mit struct für die Deklaration von Variablen benutzt wird: struct card acard;

5 5 Häufiger Programmierfehler Das Semikolon am Ende der Definition einer Struktur zu vergessen ist ein Syntaxfehler.

6 8.2 Definition von Strukturen 6 Die Definition von struct card enthält die Elemente face und suit, beide vom Typ char *. Elemente von Strukturen können Variablen primitiver Datentypen (d.h. char, int, double, usw.) oder Aggregate wie Arrays und andere Strukturen sein. Strukturen können aus vielen Elementen unterschiedlicher Typen aufgebaut sein.

7 8.2 Definition von Strukturen 7 Die folgende struct enthält die Elemente char-arrays für den Vor- und Nachnamen eines Angestellten, einen unsigned int für das Alter des Angestellten, einen char, der'm'oder'f'für das Geschlecht enthält und einen double für den Stundenlohn des Angestellten: struct employee { char firstname[ 20 ]; char lastname[ 20 ]; unsigned int age; char gender; double hourlysalary; }; // end struct employee

8 8.2.1 Selbstbezügliche Strukturen 8 Eine Struktur kann keine Instanz von sich selbst enthalten. Eine Variable vom Typ struct employee kann nicht in der Definition für struct employee erklärt werden. Ein Zeiger auf struct employee hingegen schon: struct employee2 { char firstname[ 20 ]; char lastname[ 20 ]; unsigned int age; char gender; double hourlysalary; // struct employee2 person; // ERROR! struct employee2* eptr; // pointer is okay }; // end struct employee2 Falls struct employee2 eine Instanz von sich selbst (person) enthält, ist dies ein Syntaxfehler.

9 8.2.1 Selbstbezügliche Strukturen 9 Da eptr ein Zeiger (auf den Typ struct employee2) ist, ist er als Element der Struktur employee2 erlaubt. Eine Struktur, die einen Zeiger auf den gleichen Typ von Struktur als Element enthält, wird als selbstbezügliche Struktur bezeichnet. Selbstbezügliche Strukturen werden wir im zweiten Semester verwenden, um verkettete Datenstrukturen aufzubauen.

10 8.2.2 Definition von Variablen strukturierter Datentypen 10 Die Definition einer Struktur reserviert keinen Platz im Speicher; jede Definition erzeugt vielmehr einen neuen Datentyp, der dann zur Variablendefinition benutzt wird. Struktur-Variablen werden wie Variablen anderer Typen definiert, wobei das Schlüsselwort struct als Bestandteil des Typs mit angegeben werden muss. Die Definition struct card acard, deck[ 52 ], *cardptr; deklariert acard als Variable des Typs struct card, deck als ein Array mit 52 Elementen vom Typ struct card und cardptr als Zeiger auf struct card.

11 8.2.2 Definition von Variablen strukturierter Datentypen Variablen eines gegebenen Struktur-Typs können auch deklariert werden, indem eine kommaseparierte Liste der Variablennamen zwischen die schließende geschweifte Klammer der Struktur-Definition und das abschließende Semikolon gesetzt wird. So hätte die Variablendefinition auf der vorausgegangenen Folie auch auf die folgende Weise innerhalb der Definition der struct card geschrieben werden können: struct card { char* face; char* suit; } acard, deck[ 52 ], *cardptr; 11

12 8.2.3 Bezeichner für Strukturen 12 Der Bezeichner für eine Struktur (wie das card in struct card) ist optional. Falls die Definition einer Struktur keinen Bezeichner für diese Struktur enthält, können Variablen dieses Struktur-Typs nur in der Definition dieser Struktur deklariert werden - nicht in einer separaten Deklaration.

13 13 Praxis-Tipp Bei der Definition einer neuen Struktur sollte auch immer ein Bezeichner für diese Struktur festgelegt werden. Ist dieser Bezeichner vorhanden, können auch später im Programm Variablen des entsprechenden Typs deklariert werden und das Programm wird übersichtlicher.

14 8.2.4 Operationen auf Strukturen 14 Die einzigen Operationen, die auf Strukturen ausgeführt werden können, sind: Zuweisung von Struktur-Variablen an Struktur-Variablen desselben Typs, Ermittlung der Adresse (&) einer Struktur-Variablen, Zugriff auf die Elemente einer Struktur-Variablen (s. Abschnitt 8.4), Nutzung des sizeof Operators, um die Größe einer Struktur- Variablen zu bestimmen. Struktur-Variablen dürfen nicht mit Hilfe der Operatoren == und!= verglichen werden, da ihre Elemente nicht unbedingt in aufeinanderfolgenden Bytes im Speicher abgelegt werden.

15 8.3 Initialisierung von Strukturen 15 Struktur-Variablen können wie Arrays mit Initialisierungslisten initialisiert werden. Um eine Struktur-Variable zu initialisieren, wird ihr bei der Definition eine kommaseparierte Liste von Initialisierern innerhalb geschweifter Klammern zugewiesen. Die Definition struct card acard = { "Three", "Hearts" }; erzeugt eine Variable acard vom Typ struct card (wie in Abschnitt 8.2 definiert) und initialisiert die Elemente face mit "Three" und suit mit "Hearts".

16 8.3 Initialisierung von Strukturen 16 Sind weniger Initialisierer in der Liste als Elemente in der Struktur, werden die übrigen Elemente automatisch mit 0 (oder NULL, falls das Element ein Zeiger ist) initialisiert. Struktur-Variablen, die außerhalb einer Funktionsdefinition (d.h. extern) definiert werden, werden mit 0 oder NULL initialisiert, falls sie nicht explizit initialisiert werden. Struktur-Variablen können auch durch Zuweisungen initialisiert werden, indem eine Variable desselben Typs zugewiesen wird, oder indem Werte für die einzelnen Elemente der Struktur zugewiesen werden.

17 8.4 Zugriff auf Elemente von Strukturen 17 Zwei Operatoren werden für den Zugriff auf Elemente von Strukturen benutzt: der Element- oder Punktoperator (.) und der Zeiger- oder Pfeiloperator (->). Der Punktoperator greift auf ein Element der Struktur über den Namen der Struktur-Variablen zu. Um beispielsweise das Element suit der Struktur- Variablen acard aus Abschnitt 8.3 auszugeben, kann folgende Anweisung verwendet werden: printf( "%s", acard.suit ); // displays Hearts

18 8.4 Zugriff auf Elemente von Strukturen 18 Der Pfeiloperator bestehend aus einem Minuszeichen (-) und einem Größerzeichen (>) ohne Leerzeichen dazwischen greift auf ein Element der Struktur über einen Zeiger auf die Struktur-Variable zu. Falls der Zeiger cardptr ein struct card -Zeiger ist und die Adresse der Struktur-Variablen acard diesem Zeiger zugewiesen wurde, kann das Element suit der Struktur-Variablen acard über den Zeiger cardptr wie folgt ausgegeben werden: printf( "%s", cardptr->suit ); // displays Hearts

19 8.4 Zugriff auf Elemente von Strukturen 19 Der Ausdruck cardptr->suit ist äquivalent mit dem Ausdruck (*cardptr).suit, bei dem zuerst der Zeiger dereferenziert wird und dann auf das Element suit mit dem Punktoperator zugegriffen wird. Die Klammern sind hierbei notwendig, weil der Punktoperator (.) einen höheren Vorrang hat als der Dereferenzierungsoperator (*). Pfeil- und Punktoperator haben zusammen mit Klammern (für Funktionsaufrufe) und eckigen Klammern ([]) für die Arrayindizierung den höchsten Operatorvorrang. Sie assoziieren von links nach rechts.

20 20 Praxis-Tipp Vor und hinter dem Punkt- und dem Pfeiloperator sollten keine Leerzeichen stehen. Das hilft zu betonen, dass die Ausdrücke, in denen diese beiden Operatoren stehen, im Kern die Namen von einzelnen Variablen sind.

21 21 Häufiger Programmierfehler Der Versuch, auf ein Element einer Struktur allein über den Elementnamen zuzugreifen, ist ein Syntaxfehler.

22 8.4 Zugriff auf Elemente von Strukturen 22 Das folgende Programm demonstriert den Gebrauch von Punkt- und Pfeiloperator. Mit dem Punktoperator werden den Elementen der Struktur acard die Werte "Ace" und "Spades" zugewiesen (Zeilen 16 und 17). Dem Zeiger cardptr wird die Adresse der Struktur acard zugewiesen (Zeile 19). Die Funktion printf gibt die Elemente der Struktur- Variablen acard aus, wobei der Punktoperator mit dem Variablennamen acard, der Pfeiloperator mit den Zeiger cardptr und der Punktoperator mit dem dereferenzierten Zeiger cardptr verwendet wird (Zeilen 22 bis 24).

23 1 // Fig. 8.2: fig08_02.c 2 // Structure member operator and structure pointer operator 3 #include <stdio.h> 4 5 // card structure definition 6 struct card { 7 char* face; // define pointer face 8 char* suit; // define pointer suit 9 }; // end structure card int main( void ) 12 { 13 struct card acard; // define one struct card variable 14 struct card* cardptr; // define a pointer to a struct card acard.face = "Ace"; // place strings into acard 17 acard.suit = "Spades"; cardptr = &acard; // assign address of acard to cardptr printf( "%s%s%s\n%s%s%s\n%s%s%s\n", 22 acard.face, " of ", acard.suit, 23 cardptr->face, " of ", cardptr->suit, 24 ( *cardptr ).face, " of ", ( *cardptr ).suit ); 25 } // end main Definitionen von Strukturen müssen mit einem Semikolon abgeschlossen werden. Outline fig08_02.c (1 von 1) 23 Ace of Spades Ace of Spades Ace of Spades 2006 Pearson Education, Inc. All rights reserved.

24 8.5 Strukturen und Funktionen 24 Strukturen können an Funktionen übergeben werden, indem individuelle Elemente, die ganze Struktur oder ein Zeiger auf eine Struktur übergeben werden. Wenn ganze Strukturen oder individuelle Elemente an eine Funktion übergeben werden, werden sie wertmäßig übergeben ( pass by value ). In diesem Fall können die Elemente einer Struktur- Variablen der aufrufenden Funktion in der aufgerufenen Funktion nicht verändert werden. Um eine Struktur referenzmäßig zu übergeben, muss die Adresse der Struktur-Variablen übergeben werden.

25 8.5 Strukturen und Funktionen 25 Arrays von Strukturen werden wie alle Arrays automatisch referenzmäßig übergeben. Will man ein Array wertmäßig an eine Funktion übergeben, kann man eine Struktur mit dem Array als Element definieren. Strukturen werden wertmäßig übergeben und somit wird das in ihr enthaltene Array wertmäßig übergeben.

26 26 Häufiger Programmierfehler Anzunehmen, dass Strukturen wie Arrays automatisch referenzmäßig übergeben werden und zu versuchen, die Elemente der Struktur in der aufgerufenen Funktion zu ändern, ist ein logischer Fehler. Geändert werden nur die Elemente einer lokalen Kopie.

27 27 Performanz-Tipp Strukturen referenzmäßig zu übergeben ist effizienter, da vermieden wird, alle Elemente der Struktur zu kopieren.

28 8.6 typedef 28 Das Schlüsselwort typedef bietet die Möglichkeit Synonyme (oder Zweitnamen) für zuvor definierte Datentypen zu erzeugen. Gerade für strukturierte Datentypen werden oft mit typedef kürzere Typnamen vereinbart. So definiert beispielsweise die Anweisung typedef struct card Card; den neuen Typnamen Card als ein Synonym für den Typ struct card. C Programmierer nutzen oft typedef, um einen Typ für eine Struktur zu definieren, so dass ein Bezeichner für die Struktur selbst überflüssig wird.

29 8.6 typedef 29 So erzeugt beispielsweise die folgende Definition typedef struct { char* face; char* suit; } Card; den strukturierten Datentyp Card, ohne dass eine separate typedef Anweisung nötig ist.

30 30 Praxis-Tipp Die mit typedef definierten Typnamen sollten mit Großbuchstaben beginnen, um darauf hinzuweisen, dass sie Synonyme für andere Typnamen sind.

31 8.6 typedef 31 Card kann jetzt zur Deklaration von Variablen vom Typ struct card verwendet werden. Die Deklaration Card deck[ 52 ]; erklärt ein Array von 52 Card Strukturen (d.h. Variablen vom Typ struct card). Die Erzeugung eines neuen Namens mit typedef erzeugt keinen neuen Typ; typedef erzeugt einfach einen weiteren Typnamen, der als Zweitnamen für einen existierenden Typnamen verwendet werden kann.

32 32 Praxis-Tipp Ein aussagekräftiger Name für einen neuen Typ hilft dabei, ein Programm selbstdokumentierend zu machen. Wenn man die Deklaration auf der vorausgegangenen Folie liest, weiß man, dass deck ein Array von 52 Cards ist

33 8.7 Fallstudie: Verbesserte Kartenmischund Gebesimulation 33 Das folgende Programm basiert auf der in Kapitel 7 behandelten Kartenmisch- und Gebesimulation. Das Programm modelliert das Kartenspiel als Array des strukturierten Datentyps Card und verwendet verbesserte Misch- und Gebealgorithmen.

34 1 // Fig. 8.3: fig08_03.c 2 // Card shuffling and dealing simulation using structures. 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <time.h> 6 7 #define SUITS 4 8 #define FACES 13 9 #define CARDS // card structure definition 12 struct card { 13 const char* face; // define pointer face 14 const char* suit; // define pointer suit 15 }; // end structure card 16 Outline fig08_03.c (1 von 4) card ist ein neuer Datentyp, der zwei Zeiger auf char zusammenfasst. Card ist ein Zweitname für den Typ struct card. 17 typedef struct card Card; // new type name for struct card // prototypes 20 void filldeck( Card * const, const char * [], const char * [] ); 21 void shuffle( Card * const ); 22 void deal( const Card * const); Pearson Education, Inc. All rights reserved.

35 24 int main( void ) 25 { 26 // initialize suit array 27 const char* suit[ SUITS ] = 28 { "Hearts", "Diamonds", "Clubs", "Spades" }; // initialize face array 31 const char* face[ FACES ] = 32 { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", 33 "Eight", "Nine", "Ten", "Jack", "Queen", "King" }; // initialize deck array 36 Card deck[ CARDS ]; 38 Card-Array enthält 52 Card-Strukturen 39 srand( ( unsigned ) time( NULL ) ); // seed random-number generator filldeck( deck, face, suit ); // load the deck with Cards 42 shuffle( deck ); // put Cards in random order 43 deal( deck ); // deal all 52 Cards 44 } // end main 45 Outline fig08_03.c (2 von 4) Pearson Education, Inc. All rights reserved.

36 46 // place strings into Card structures 47 void filldeck( Card * const deck, const char * face[], const char * suit[] ) 48 { 49 size_t i; // loop counter // loop through deck 52 for( i = 0; i < CARDS; ++i ) { 53 deck[ i ].face = face[ i % FACES ]; 54 deck[ i ].suit = suit[ i / FACES ]; 55 } // end for 56 } // end function filldeck // shuffle cards in deck 60 void shuffle( Card* const deck ) 61 { 62 size_t i; // loop counter 63 size_t randindex; // variable to hold random value between 0 and Card temp; // temporary struct for swapping Cards // loop through deck randomly swapping Cards 67 for( i = 0; i < CARDS; ++i ) { 68 randindex = rand() % CARDS; 69 temp = deck[ i ]; 70 deck[ i ] = deck[ randindex ]; 71 deck[ randindex ] = temp; 72 } // end for 73 } // end function shuffle Outline fig08_03.c (3 von 4) Pearson Education, Inc. All rights reserved.

37 74 75 // deal cards 76 void deal( const Card * const deck ) 77 { 78 size_t i; // loop counter 79 size_t row; // loop counter 80 size_t column; // loop counter // loop through deck 83 for( i = 0; i < CARDS; ++i ) 84 printf( "%5s of %-8s%s", deck[ i ].face, deck[ i ].suit, 85 ( i + 1 ) % 4? " " : "\n" ); // 4-column format 86 puts( "" ); 87 } // end function deal Outline fig08_03.c (4 von 4) 37 Seven of Clubs Three of Hearts Five of Hearts Ten of Hearts Seven of Diamonds Eight of Diamonds Nine of Diamonds Four of Clubs Four of Hearts Ace of Clubs Nine of Hearts Queen of Diamonds Jack of Clubs Eight of Clubs Six of Spades Deuce of Diamonds Queen of Spades Ace of Hearts Six of Diamonds Six of Clubs Jack of Diamonds Four of Spades Five of Diamonds Queen of Hearts Jack of Hearts Queen of Clubs Ace of Spades Three of Clubs Ace of Diamonds King of Clubs Deuce of Spades Seven of Hearts Ten of Diamonds King of Hearts Four of Diamonds Nine of Spades Deuce of Hearts Five of Spades Ten of Clubs Deuce of Clubs King of Diamonds Three of Diamonds Seven of Spades Nine of Clubs Five of Clubs Eight of Hearts King of Spades Three of Spades Ten of Spades Eight of Spades Jack of Spades Six of Hearts 2006 Pearson Education, Inc. All rights reserved.

38 38 Häufiger Programmierfehler Falls man eine individuelle Struktur in einem Array von Strukturen ansprechen möchte und hierbei der Arrayindex vergessen wird, resultiert ein Syntaxfehler.