Strukturen

• Grundprinzip.
• Komponenten einer Struktur.
• Zeiger auf Strukturen.
• Arrays von Stukturen.

struct wird verwendet, um einen neuen (nutzerdefinierten)  Datentyp einzuführen. In Strukturen kann man Variablen verschiedenen Datentyps zu einer Einheit zusammenfassen. Zum Beispiel kann man die folgenden Daten

          
   Jo		Loss		Maths		A   
   Harry	Carpenter	English 	A
   Billy	King		Maths		C

wie folgt in einer Struktur beschreiben:

   

   struct
   {
     char cname[8];
     char sname[16];   
     char exam[16];
     char grade;
   } record;

Mit dieser Anweisung wird eine Variable record definiert, die  4 einfache Variablen (cname, sname, exam, grade) enthält. Die Struktur als Ganzes kann mit   record angesprochen werden, eine Komponete mit Hilfe einer Punktnotation   record.exam

Strukturen können auf verschiedene Art und Weise definiert bzw. deklariert werden.

	struct type_x {int a; int b; int c;};	/* Deklariere einen Typ namens type_x	*/
	struct 	 {int a; int b; int c;} var_z;  /* Definiere eine Variable namens var_z     */
	struct type_x var_z;                    /* dito, hier wird var_z von type_x abgeleitet */

Welche Variante man wählt hängt von der Anwendung ab:

• Im ersten Beispiel erhält die Struktur einen Namen (d.h. es wird ein neuer Datentyp mit einem neuen Namen eingeführt) - optional.
• Im ersten und zweiten Beispiel werden Komponeten der Struktur vereinbart.
• Im zweiten Beispiel wird eine Variable  (bestehend aus drei Integerzahlen) definiert.
• Im dritten Beispiel wird ebenfalls eine Variable definiert, hier wird sie aber von Datentyp type_x abgeleitet.

	
   struct x {int a; int b; int c;};   

   main()
   {
     struct x z;
     
     z.a = 10;
     z.b = 20;
     z.c = 30;
   }
   

   struct x
   {
     int a;
     int b;
     int c;
   };

   main()
   {
     struct x z;
	
     z.a = 10;
     z.a++;

     printf(" first member is %d \n", z.a);   
   }
   

Erklärung zum -> Operator.

Bisher wurde der Fall, daß eine Struktur an eine Funktion übergeben werden soll, nicht berücksichtigt. Die Arbeit mit Strukturvariablen ist hier ungünstig, da:

• Bei großen Strukturen ist es effektiver, an Stelle der Struktur selbst einen  Zeiger auf die Struktur zu übergeben. Man verwendet die gleiche Technik um  Arrays an  Funktionen zu übergeben, auch dort übergibt man nur einen Zeiger auf die Daten.
• Wenn man eine Struktur an eine Funktion übergibt, dann ist das eine Kopie. Deshalb könnte man auf Ergebnisse, die innerhalb einer Funktion erzeugt werden, nicht zugreifen, weil sie am Ende der Funktion verloren gehen.

Im folgenden Beispiel wird das Prinzip der Datenübergabe mit und ohne Zeiger demonstriert.

					|
					|
   struct x {int a; int b; int c;} ;	| struct x {int a; int b; int c;} ;
					|
   void function(struct x);		| void function(struct x *);
					|
   main()			       	| main()
   {					| {
     struct x z;                        |   struct x z, *pz;	     /* 3 */
					|   pz = &z;		     /* 4 */
     z.a = 10;		/* 1 */		|   z.a = 10;
     z.a++;				|   z.a++;
					|
     function(z);	/* 2 */	        | function(pz);		     /* 5 */
   }					| }
					|
   void function( struct x z)		| void function(struct x * pz)
   {					| {			     /* 6 */
     printf(" first member %d \n", z.a);|   printf(" first member %d \n", (*pz).a);   
   }					| }
					|

Zur Erklärung.

1. Komponente einer Struktur erhält einen Wert.
2. Übergebe eine Kopie der ganzen Struktur an eine Funktion.
3. Definiere 'pz' als Zeiger auf eine Struktur vom Typ 'x'.
4. Lege Adresse von  'z' in 'pz' ab. 'pz' zeigt jetzt auf 'z'.  Beachten Sie: In 'z' wird Speicherplatz reserviert, in dem die ganze Struktur Platz findet . 'pz' kann nur eine Adresse aufnehmen..
5. Übergebe einen Zeiger an die Funktion.
6. Gebe den Wert einer Komponente aus.

	(*pz).a   ==  pz->a

   /*************************************************************************/    

   struct x {int a; int b; int c;} ;	/* Deklariere eine Struktur	    */

   void Funktion(struct x * );		/* Deklariere eine Funktion 	    */

   /*************************************************************************/

   main() 
   {  
					/* Dekl. zwei Variablen.
					 * z == Variable von Typ struct x
					 * pz == Zeiger auf Variable vom Typ struct x
					 */
     struct x z, *pz; 			

     pz = &z;        			/* Adresse von 'z' nach 'pz' */
     z.a = 10;				/* Initialisiere z.a		    */
     z.a++;				/* Inkrementiere z.a		    */

					/* Ausgabe der Komponente 'z.a'
					 * unter Ausnutzung des Zeigers 'pz'	    */
   
     printf(" first member before the Funktion call %d \n", pz->a);

					/* Aufruf 'function' mit Übergabe 
					 * des Zeigers 'pz'			    */
     function(pz);  			

					/* Ausgabe des neuen Wertes in 'z.a'
					 * mit drei Notationen  */
     printf(" first member after the Funktion call %d \n", pz->a);
     printf(" first member after the Funktion call %d \n", (*pz).a);
     printf(" first member after the Funktion call %d \n", z.a);

   }

   /*************************************************************************/
   
   void function(struct x * pz)
   { 
					/* Ausgabe des Wertes in 'z.a' durch
					 * Referenzierung des Zeigers 'pz'
					 * der die Adresse von 'z' enthält  */
     printf(" first member inside the Funktion %d \n", pz->a);
      
					/* Erhöhe den Wert in  'z.a'
					 * hier wird der Speicherplatz
					 * der Komponente a angesprochen	    */
     pz->a++;
     
   }

   /*************************************************************************/
  

Ein sehr einfaches Beispiel.
Arbeit mit Komponenten.
Übergabe einer Struktur an eine Funktion. 
Definition und Benutzung von Arrays von Strukturen.
  Eine Programmieraufgabe.

Siehe auch:

Schlüsselwort typedef .
Linked lists.