Strukturen



Grundprinzip

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:


Komponenten einer Struktur

Auf Komponeten einer Struktur kann man  mit dem  . Operator zugreifen, z.B.:

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

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

Man kann damit auch Komponenten einer Struktur auslesen.


   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);   
   }
   

Zeiger auf Strukturen

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:

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.

Die Syntax  (*zeiger).komponente kann mit dem Operator -> auch abgekürzt geschrieben werden:

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

Das Beispielprogramm zusammengefaßt:




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

   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++;
     
   }

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


Beispiele

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.


Anfang Hauptindex Schlüsselwörter Funktionen

Übers.: G. Junghanns