Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1411-7
Pfeil 15 Strukturen
Pfeil 15.1 Struktur deklarieren
Pfeil 15.2 Initialisierung und Zugriff auf Strukturen
Pfeil 15.3 Strukturen als Wertübergabe an eine Funktion
Pfeil 15.4 Strukturen als Rückgabewert einer Funktion
Pfeil 15.5 Strukturen vergleichen
Pfeil 15.6 Arrays von Strukturen
Pfeil 15.7 Strukturen in Strukturen (Nested Structures)
Pfeil 15.8 Kurze Zusammenfassung zu den Strukturen
Pfeil 15.9 Unions
Pfeil 15.10 Der Aufzählungstyp »enum«
Pfeil 15.11 Typendefinition mit »typedef«
Pfeil 15.12 Attribute von Strukturen verändern (nicht ANSI C)
Pfeil 15.13 Bitfelder
Pfeil 15.14 Das »offsetof«-Makro


Rheinwerk Computing - Zum Seitenanfang

15.11 Typendefinition mit »typedef« topZur vorigen Überschrift

Mit dem Schlüsselwort typedef kann ein neuer Bezeichner für einen einfachen Datentyp verwendet werden. Die Syntax einer einfachen Typendefinition sieht so aus:

typedef Typendefinition Bezeichner;

Damit lässt sich die Lesbarkeit eines Programms erheblich verbessern. Diese Typendefinition mit typedef soll anhand des Adressprogramms demonstriert werden. Hier sehen Sie das Listung dazu:

/* typedef1.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX 30

static int x;

struct adres {
   char vname[MAX];
   char nname[MAX];
   long PLZ;
   char ort[MAX];
   int geburtsjahr;
} adressen[100];

typedef struct adres ADRESSE;

void Eingabe(int nr, ADRESSE *neu) {
   printf("Vorname : ");
   fgets(neu[nr].vname, MAX, stdin);
   printf("Nachname : ");
   fgets(neu[nr].nname, MAX, stdin);
   printf("Postleitzahl: ");
   do {
      scanf("%5ld",&neu[nr].PLZ);
   } while(getchar()!= '\n');
   printf("Wohnort : ");
   fgets(neu[nr].ort, MAX, stdin);
   printf("Geburtsjahr : ");
   do {
      scanf("%4d",&neu[nr].geburtsjahr);
   } while(getchar()!= '\n');
}
void Suche(ADRESSE *search, char buchstabe, int nr) {
   int i;
   for(i = 0; i <= nr; i++)  {
      if(search[i].nname[0] == buchstabe) {
         printf("\n\nGefunden unter Buchstabe :\"%c\"\n\n",
            buchstabe);
         printf("Vorname.......:%s",search[i].vname);
         printf("Nachname......:%s",search[i].nname);
         printf("Postleitzahl..:%ld\n",search[i].PLZ);
         printf("Ort...........:%s",search[i].ort);
         printf("Geburtsjahr...:%d\n",search[i].geburtsjahr);
         printf("\n\tWeiter mit <ENTER>\n");
         getchar();
      }
   }
}

void Ausgabe(ADRESSE *all, int nr) {
   int i;

   for(i = 0; i < nr; i++) {
      printf("Vorname.........:%s",all[i].vname);
      printf("Nachname........:%s",all[i].nname);
      printf("Postleitzahl....:%ld\n",all[i].PLZ);
      printf("Ort.............:%s",all[i].ort);
      printf("Geburtsjahr.....:%d\n\n",all[i].geburtsjahr);

      if( (!(i%2)) && i!=0)  {
         //fflush(stdin);
         printf("\n\tWeiter mit <Enter>\n\n");
         getchar();
      }
   }
}

void Sort(ADRESSE *sort,int nr) {
   ADRESSE *temp;
   int i,j;

   temp = malloc(sizeof(ADRESSE *));
   if(NULL == temp) {
      printf("Konnte keinen Speicher reservieren ...\n");
      return;
   }

   for(i = 0; i < nr; i++) {
      for(j=i+1;j<nr;j++) {
         if(strcmp(sort[i].nname, sort[j].nname)>0) {
            *temp=sort[j];
            sort[j]=sort[i];
            sort[i]=*temp;
         }
      }
   }
   printf("... sortiert!!\n");
}

int main(void) {
   int auswahl;
   char c;

   do {
      printf("-1- Neue Adresse eingeben\n");
      printf("-2- Bestimmte Adresse ausgeben\n");
      printf("-3- Alle Adressen ausgeben\n");
      printf("-4- Adressen sortieren\n");
      printf("-5- Programm beenden\n");
      printf("\nIhre Auswahl : ");
      scanf("%d",&auswahl);
      /* fflush(stdin); */
      getchar();
      switch(auswahl) {
         case 1 : Eingabe(x++,adressen);        break;
         case 2 : printf("Anfangsbuchstabe Nachnamen :");
                  do {
                     scanf("%c",&c);
                  } while(getchar()!= '\n');
                  Suche(adressen,c,x);
                  break;
         case 3 : Ausgabe(adressen,x);          break;
         case 4 : Sort(adressen,x);             break;
         default: break;
      }
   } while(auswahl < 5);
   return EXIT_SUCCESS;
}

Dank der neuen Typdefinition

typedef struct adres ADRESSE;

kann auf die Struktur jetzt mit

ADRESSE neueadressen[100];

zugegriffen werden. Dies lässt sich bei längeren Programmen wesentlich einfacher lesen. Vor allem ist dies sinnvoll, wenn mehrere Strukturen vorhanden sind, die einander vom Aufbau sehr ähnlich sind. Die Typdefinition im Programm ließe sich auch noch anders definieren:

typedef struct adres {
   char vname[20];
   char nname[20];
   long PLZ;
   char ort[20];
   int geburtsjahr;
} ADRESSE;
...
ADRESSE adressen[100];

Die Typdefinition kann ebenso auf andere Variablen angewendet werden. Recht häufig sind folgende Definitionen zu sehen:

typedef unsigned char BYTE;    // 1 Byte = 8 BIT
typedef unsigned int WORD;     // 1 WORD = 16 BIT
typedef unsigned long DWORD;   // 1 DOUBLE WORD = 32 BIT
typedef unsigned double QWORD; // 1 QUAD WORD = 64 BIT
typedef unsigned int uint;
typedef unsigned char uchar;

Zum Beispiel ist danach die folgende Schreibweise

uint wert1, wert2;

äquivalent zu:

unsigned int wert1,wert2;

Das Schlüsselwort typedef wird ebenfalls dazu benutzt, sogenannte primitive Datentypen zu erzeugen. Wozu soll das gut sein? Nehmen wir als Beispiel den primitiven Datentyp uclock_t (primitive Datentypen enden normalerweise immer mit _t). Dieser ist in der Headerdatei <time.h> definiert mit:

typedef long uclock_t;

Auf einem anderen System sieht diese Definition vielleicht so aus:

typedef unsigned int uclock_t;

Die primitiven Datentypen machen ein Programm portabler. Dadurch müssen Sie sich nicht mit den Datentypen bei der Portierung auf andere Systeme auseinandersetzen. Wenn Sie ein Programm beispielsweise auf einem 32-Bit-System programmiert haben und dies anschließend auf einem 16-Bit-System getestet wird, kann die Suche nach dem Fehler einer falschen Werteausgabe frustrierend sein.

Wie schon mit enum oder define wird mit typedef das Programm nicht etwa besser oder schneller, sondern es dient auch hier lediglich dazu, dass sich Ihr Programm besser lesen, schreiben und auf andere Systeme portieren lässt.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: C/C++






 C/C++


Zum Katalog: Einstieg in C






 Einstieg in C


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de