1:

pkws+=anzahl;

1:
2:
3:
4:
5:

+------+------+
|Auto 1|Auto 2|
+------+------+
^
|

1:
2:
3:
4:
5:

+------+------+
|Auto 1|Auto 2|
+------+------+
               ^
               |

1:

pkws+=(anzahl-1);

1:
2:
3:
4:
5:
6:
7:
8:
9:

void funktion(int parameter)
{
   // Blabla
}

void funktion()
{
   // Blabla 2
}

1:
2:

funktion(5);
funktion();

1:
2:
3:
4:
5:
6:
7:
8:

+-----------------+-----------------+-----------------+
|Array mit        |Array mit        |Array nur für    |
|Werten 1         |Werten 2         |Abbruch          |
+-----------------+-----------------+-----------------+
                                    ^
                                    |

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:

#include <stdio.h>

#define MAXLEN 30
#define NEU 1
#define EINGABE 2
#define AUSGABE 3
#define LOESCHEN 4
#define ENDE 5

struct wagen {
char name[MAXLEN];    /* Name des Autos */
float speed;          /* Geschwindigkeit */
int zylinder;         /* Anzhl der Zilynder */
int ps;               /* Anzahl der PS */
char gas;             /* Art des Benzins S=Super, N=Normal, D=Diesel */
int abbruch;
};

void eingabe(struct wagen *,struct wagen *);
void ausgabe(struct wagen *,struct wagen *);
void del();
void new();
int menu();

int main()
{
struct wagen *pkws,*control;
short choice;
for(;;)
{
choice=menu();
switch (choice) {
               case NEU: 
                    new();
                    break;
               case EINGABE: 
                    eingabe(pkws,control);
                    break;
               case AUSGABE: 
                    ausgabe(pkws,control);
                    break;
               case LOESCHEN: 
                    del();
                    break;
               case ENDE:
                    return 0;
               default:
                       printf("Ungueltige Eingabe");
                       break;
               }
}
system("PAUSE");
}

void eingabe(struct wagen *pkws,struct wagen *control)
{
short index,anzahl=1;
FILE *file;
char name[20],ch='N';
fflush(stdin);
printf("\n\nWie heist die Datei in die sie schreiben wollen\n");
printf("(Falls die Datei nicht existiert wird sie angelegt)    ");
gets(name); 
printf("\n\nWie viele Autos wollen sie speichern  ");
do{scanf("%d",&anzahl); } while(getchar()!='\n');
pkws=malloc((anzahl+1)*sizeof(struct wagen));
if(!pkws)
{
printf("\nNicht genug freier Speicher verfuegbar");
system("PAUSE");
}
control=pkws;
pkws+=anzahl;
pkws->abbruch=-1;
pkws=control;

for(;ch=='N' || ch=='n';)
{

printf("\nBitte machen sie Eingaben fuer %d Autos",anzahl);
printf("\nBitte machen sie ihre Eingaben");
printf("\nnach dem Syntax name,temp,anzahl zylinder,ps und benzing");
printf("\nzB Audi a3 350.0 4 300 S\n");
for(index=1;pkws->abbruch!=-1;pkws++,index++)
{
fflush(stdin);
printf("\nMachen sie ihre eingabe fuer das %d. Auto\n",index);
gets(pkws->name);
do{scanf(" %f %d %d %c",&pkws->speed,&pkws->zylinder,&pkws->ps,&pkws->gas); } while(getchar()!='\n');
}
pkws=control;
 printf("\nSie haben folgende Daten angegeben");
for(pkws=control;pkws->abbruch!=-1;pkws++)
{
printf("\nDie Daten der Autos\n");
printf("Name %s | Tempo %f | Zylinder %d | PS %d | Benzin %c\n\n",pkws->name,pkws->speed,pkws->zylinder,pkws->ps,pkws->gas);
}
printf("\nWenn sie diese Daten in die Datei schreiben wollen druecken sie J\n");
printf("Um die Daten nocheinmal einzugeben druecken sie N  ");
fflush(stdin);
scanf("%c",&ch);
pkws=control;
}
file=fopen(name,"a");
if(!file) printf("Konnte Datei nicht oeffnen");
for(pkws=control;pkws->abbruch!=-1;pkws++)
{
                              fprintf(file,"%s\n",pkws->name);
                              fprintf(file,"%f\n",pkws->speed);
                              fprintf(file,"%d\n",pkws->zylinder);
                              fprintf(file,"%d\n",pkws->ps);
                              fprintf(file,"%c\n",pkws->gas);
                              fprintf(file,"\n");
                              }
pkws=control;
fclose(file);
}

void ausgabe(struct wagen *pointer,struct wagen *control)
{
  

}

int menu()
{
    int choice=0;
    printf("***** Car Data 1.0 *****\n\n");
    printf("Bitte treffen sie eine Wahl\n\n");
    printf("1 - Eine neue Datei zum Speichern von Auto Daten anlegen\n");
    printf("2 - Neue Autodaten eingeben und speichern\n");
    printf("3 - Vorhandene Auto Daten ausgeben lassen\n");
    printf("4 - Eine Datei mit Auto Daten loeschen\n");
    printf("\n5- Programm beenden\n\n");
    scanf("%d",&choice);
    return(choice);
}
    
void new()
{
     FILE *pointer;
     char name[10];
     fflush(stdin);
     printf("\nWie soll die Datei heisen (dateiendung bitte .txt)    ");
     gets(name);
     pointer=fopen(name,"w");
     if(!pointer) printf("Konnte Datei nicht anlegen");
                 
                 else printf("Datei erfolgreich angelegt\n\n");
}

void del()
{
}

1:
2:
3:
4:
5:
6:

struct wagen {
int 1;
int 2;
int 3;
struct wagen *pointer_next;
};

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

struct wagen *pointer_aktuell;
char choice='J';
pointer_aktuell=malloc(sizeof(struct wagen));
for(;ch=='j' || ch=='J';pointer_aktuell=pointer_aktuell->pointer_next;)
{
printf("eingabe eins:   ");
scanf("%d",&pointer_aktuell->1);
.....
pointer_aktuell->pointer_next=malloc(sizeof(struct wagen);
printf("Noch ne eingabe? j/n");
scang("%c",&choice);
}
return 0;
}

1:

fprintf(filepointer,"%s",pointer->inhalt);

1:

fwrite(*inhalt_von_pointer,sizeof(*pointer),1,file);

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct foobar{

       int a,b,c;
       char dummy[5];
       struct foobar *next;
       
};


int main () {
    
    struct foobar *test;
    FILE *fp;
    
    test=(struct foobar*)calloc(1,sizeof(struct foobar));
    test->a=1;
    test->b=2;
    test->c=3;
    memcpy(&test->dummy,"blah",4);
    test->next=test;
    
    fp=fopen("c:\\test.dat","wb");
    printf("%d\n",fwrite(test,sizeof(struct foobar),1,fp));
    fclose(fp);
    free(test);
    system("pause");
    return 0;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct fahrzeug{

       unsigned int preis;
       char *name;
       unsigned int namelen;
       unsigned int leistung;
       unsigned int typ; /* 0=pkw 1=lkw 2=zug 3=schiff*/
       union{
             struct{
                    unsigned int sitze;
             } pkw;
             struct{
                    unsigned int achsen;
                    unsigned int ladefl;
                    unsigned int maxgewicht;
             } lkw;
             struct{
                    unsigned int schrauben;
                    unsigned int tiefgang;
                    unsigned int decks;
             }schiff;
             struct{
                    unsigned int laenge;
                    unsigned int sitzpl;
                    unsigned int stehpl;
             } zug;
       }daten;
       struct fahrzeug *next;
       
};

void hr()
{
     printf("-----------------------------\n");
}

void show_fahrzeug(struct fahrzeug *ptr)
{
     char *typ;
     switch(ptr->typ){
         case 0:
              typ="PKW";
              break;
         case 1:
              typ="LKW";
              break;
         case 2:
              typ="Zug";
              break;
         case 3:
              typ="Schiff";
              break;
         default:
              typ="Unbekannt";
     }
     hr();
     printf("Typ:\t%s\n",typ);
     hr();
     printf("Daten:\nPreis:\t\t%d\nName:\t\t%s\nLeistung:\t%d\n\n",ptr->preis,ptr->name,ptr->leistung);
     switch(ptr->typ){
         case 0:
              printf("Sitzplaetze:\t%d\n",ptr->daten.pkw.sitze);
              break;
         case 1:
              printf("Achsen:\t\t%d\nLadeflaeche:\t%d\nMaximalgewicht:\t%d\n",ptr->daten.lkw.achsen,ptr->daten.lkw.ladefl,ptr->daten.lkw.maxgewicht);
              break;
         case 2:
              printf("Laenge:\t\t%d\nSitzplaetze:\t%d\nStehplaetze:\t%d\n",ptr->daten.zug.laenge,ptr->daten.zug.sitzpl,ptr->daten.zug.stehpl);
              break;
         case 3:
              printf("Schrauben:\t\t%d\nTiefgang:\t%d\nDecks:\t\t%d\n",ptr->daten.schiff.schrauben,ptr->daten.schiff.tiefgang,ptr->daten.schiff.decks);
              break;
     }
     hr();
}

char* readstring()
{
      char *s[2];
      char c;
      int idx=0,jdx=1,xor=0;
      
      s[0]=(char*)calloc(10,sizeof(char));
      while((c=getchar())!='\n')
      {
           if(idx%10==9)
           {/*bevor fragen auftauchen ... das ist mein ersatz für realloc*/
               s[xor^1]=(char*)calloc(++jdx*10,sizeof(char));
               memcpy(s[xor^1],s[xor],idx);
               free(s[xor]);
               s[xor]=NULL; /*der form halber*/
               xor=xor^1;
           }
           *(s[xor]+(idx++))=c;
      }
      s[xor^1]=(char*)calloc(idx+1,sizeof(char));
      memcpy(s[xor^1],s[xor],idx);
      free(s[xor]);
      return s[xor^1];
}

int main () {
    
    struct fahrzeug *ptr,*base,*next;
    FILE *fp;
    unsigned int num=0;
    unsigned int dummy;
    char c;
    
    base=(struct fahrzeug*)calloc(1,sizeof(struct fahrzeug));
    ptr=base;
    next=base;
    fp=fopen("c:\\test.dat","rb");
    if(fp)
          while(1)
          {
               if(fread(next,sizeof(struct fahrzeug),1,fp)==0)
               {
                     /*es ist ein fehler in der datei, oder es liegen keine weiteren daten vor --- error handling*/
                     memset(next,0,sizeof(struct fahrzeug));
                     break;
               }
               if(next->namelen<1)
               {
                     /*name nicht vorhanden --> nullstring*/
                     next->name=(char*)calloc(1,sizeof(char));
               }
               else
               {
                     next->name=calloc(next->namelen+1,sizeof(char));
                     if(fread(next->name,sizeof(char),next->namelen,fp)==0)
                     {
                         free(next->name);
                         memset(next,0,sizeof(struct fahrzeug));
                         break;
                     }
               }
               next->next=(struct fahrzeug*)calloc(1,sizeof(struct fahrzeug));
               next=next->next;
               num++;
               if(fread(&dummy,sizeof(unsigned int),1,fp)==0)
               {
                     /*es ist ein fehler in der datei --- error handling*/
                     break;
               }
               if(dummy!=0xdeadbeef)
               {
                     /*es ist ein fehler in der datei --- error handling*/
                     break;
               }
          }
    fclose(fp);
    
    if(num>0)
    {
             printf("Es wurden %d Eintraege gelesen\n",num);
             for(;ptr->next;ptr=ptr->next)
                 show_fahrzeug(ptr);
    }
    printf("Ein neues Fahrzeug eingeben?(J/N)\n");
    c=(char)0x00;
    while(c==(char)0x00)
    {
        scanf("%1[jJnN]",&c);
        fflush(stdin);
    }
    if(c=='j'||c=='J')
    {
        /*eingabe*/
        printf("Name des Fahrzeugs?\n");
        next->name=readstring();
        next->namelen=strlen(next->name);
        fflush(stdin);
        printf("Typ waehlen:(0=PKW 1=LKW 2=Zug 3=Schiff)\n");
        c=(char)0x00;
        while(c==(char)0x00)
        {
            scanf("%1[0123]",&c);
            fflush(stdin);
        }
        next->typ=(unsigned int)(c-'0');
        switch(c)
        {
                 case '0':
                      printf("PKW gewaehlt.\nGeben Sie mit Leerzeichen getrennt ein: Leistung, Preis, Sitze\n(nur ganze Zahlen ohne Einheiten)\n");
                      scanf("%d %d %d",&next->leistung,&next->preis,&next->daten.pkw.sitze);
                      break;
                 case '1':
                      printf("LKW gewaehlt.\nGeben Sie mit Leerzeichen getrennt ein: Leistung, Preis, Achsen, Ladeflaeche, Maximalgewicht\n(nur ganze Zahlen ohne Einheiten)\n");
                      scanf("%d %d %d %d %d",&next->leistung,&next->preis,&next->daten.lkw.achsen,&next->daten.lkw.ladefl,&next->daten.lkw.maxgewicht);
                      break;
                 case '2':
                      printf("Zug gewaehlt.\nGeben Sie mit Leerzeichen getrennt ein: Leistung, Preis, laenge, Sitzplaetze, Stehplaetze\n(nur ganze Zahlen ohne Einheiten)\n");
                      scanf("%d %d %d %d %d",&next->leistung,&next->preis,&next->daten.zug.laenge,&next->daten.zug.sitzpl,&next->daten.zug.stehpl);
                      break;
                 case '3':
                      printf("Schiff gewaehlt.\nGeben Sie mit Leerzeichen getrennt ein: Leistung, Preis, Schrauben, Tiefgang, Decks\n(nur ganze Zahlen ohne Einheiten)\n");
                      scanf("%d %d %d %d %d",&next->leistung,&next->preis,&next->daten.schiff.schrauben,&next->daten.schiff.tiefgang,&next->daten.schiff.decks);
                      break;
        }
        /*daten erfasst*/
        fp=fopen("c:\\test.dat","wb");
        dummy=0xdeadbeef;
        if(!fp)
        {
               printf("Datei kann nicht zum schreiben geoeffnet werden.");
        }
        else
            for(ptr=base;ptr;ptr=ptr->next)
            {
                 fwrite(ptr,sizeof(struct fahrzeug),1,fp);
                 fwrite(ptr->name,sizeof(char),ptr->namelen,fp);
                 fwrite(&dummy,sizeof(unsigned int),1,fp);
            }
    }
    
    /*aufräumen*/
    for(ptr=base;ptr;)
    {
        struct fahrzeug *tmp;
        tmp=ptr->next;
        free(ptr->name);
        free(ptr);
        ptr=tmp;
    }
    system("pause");
    return 0;
}

1:
2:
3:
4:
5:
6:
7:

typedef struct datenvektor_ {

        struct datenvektor_ *next;
        int typ;
        void *data;
       
} datenvektor;