Kadaj

Ei, danke dir, daran hab ich ja garnicht gedacht. Ich dachte, das wäre richtig, weil ich mir den Inhalt des Pointers probehalber gleich hab ausgeben lassen. Dann muss ich ja einfach nur beide Pointer bei der Zuweisung dereferenzieren: { *(tree->data)=*data; printf("datapointer nach füllen:\n %s \n",*(tree->data)); } [/PHP] Scheinbar habe ich Pointerarithmetik noch nicht ganz verstanden, denn nun ist meine Ausgabe: [PHP] # ./tree log Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben: Anna data-array:Anna data-pointer:(null) Speicherzugriffsfehler Ich hab dem Pointer Speicher geserviert und den Wert von data zugewiesen, warum ist tree->data dann (null), :confused: das versteh ich grad nicht...

Moment, ich seh grade, dass ich eine Funktion nicht mit rüber kopiert ( printtree ) habe, wie ungeschickt. So sieht es vollständig aus: #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct sort { char *data; struct sort *l; struct sort *r; }sort; sort *tree; sort init={}; void add(sort *tree,char *data) { if(tree->data==NULL) { tree->data=data; } else { if(strcmp(data,tree->data)<0) // data ist kleiner, nach links { // rücke nach links if(tree->l==NULL) { tree->l=malloc(sizeof(sort)); // Speicher reservieren *(tree->l)=init; // initialisieren mit struct sort } add(tree->l,data); // Rekursion, bis Elememt eingetragen wird } else // data ist größer, also nach rechts damit { if(tree->r==NULL) { tree->r=malloc(sizeof(sort)); // Speicher reservieren *(tree->r)=init; // initialisieren mit struct sort } add(tree->r,data); // Rekursion, bis Elememt eingetragen wird } } printf("bisheriger Baum:\n"); printtree(tree); }void printtree(sort *tree) { if(tree) // Name vorhanden? { puts(tree->data); // Name nach stdout schreiben printtree(tree->r); // Funktion rekursiv für rechtes Element aufrufen printtree(tree->l); // Funktion rekursiv für linkes Element aufrufen } } void log(FILE *file) { if(tree->data!=NULL) // Name vorhanden? { fprintf(file,tree->data); // Name nach stdout schreiben log(tree->r); // Funktion rekursiv für rechtes Element aufrufen log(tree->l); // Funktion rekursiv für linkes Element aufrufen } } int main(int argc,char *argv[]) { FILE *file; // Pointer für Logfile char puffer[64]; // Array für Namens-Eingabe tree=malloc(sizeof(sort)); // Speicher reservieren *tree=init; // initialisieren mit struct sort if(argc!=2) { perror("usage: <program> <logfile>"); exit(EXIT_FAILURE); } file=fopen(argv[1],"a+t"); if(file==NULL) { perror("erro: open file"); exit(EXIT_FAILURE); } while(strcmp(puffer,"qq")!=0) { printf("Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben:\n"); fgets(puffer,64,stdin); puffer[strlen(puffer)-1]=0; if(strcmp(puffer,"qq")!=0) add(tree,puffer); } printf("Hier die Ausgabe für den gesamten Baum:\n"); printtree(tree); log(file); // Baum in die Logfile schreiben fclose(file); return 0; } [/PHP] Wenn ich nur deinen Blick hätte ... Nun, in der Funktion add wird überprüft ob ein Eintrag in der übergebenen Struktur von Typ sort in data vorhanden ist. Wenn nicht, dann wird dem Zeiger auf data(in der Struktur) den Wert von data(des Array zugewiesen) ... Ich glaub ich versteh nicht worauf du hinaus willst. In meiner Struktur sort hab ich einen Zeiger auf ein char-Array für die Namen und jeweils 2 auf genau die selbe Struktur sort, einmal für links und einmal für rechts. Ich seh nichts, was ich falsch dereferenziert haben könnte... hmmm...

Hallo, ich versuche grad ein Programm zu schreiben, welches Namen von stdin einliest und diese dann in eine, von mir angelegte Struktur, einsortiert. Diese Daten lasse ich nach jedem Schreiben ausgeben und am Ende. So richtig funktioniert das aber noch nicht, ich fummel schon eine Weile am Code herum, aber es wird nicht besser. Hier erstmal der Quellcode: #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct sort { char *data; struct sort *l; struct sort *r; }sort; sort *tree; sort init={}; void add(sort *tree,char *data) { if(tree->data==NULL) { tree->data=data; } else { if(strcmp(data,tree->data)<0) // data ist kleiner, nach links { // rücke nach links if(tree->l==NULL) { tree->l=malloc(sizeof(sort)); // Speicher reservieren *(tree->l)=init; // initialisieren mit struct sort } add(tree->l,data); // Rekursion, bis Elememt eingetragen wird } else // data ist größer, also nach rechts damit { if(tree->r==NULL) { tree->r=malloc(sizeof(sort)); // Speicher reservieren *(tree->r)=init; // initialisieren mit struct sort } add(tree->r,data); // Rekursion, bis Elememt eingetragen wird } } printf("bisheriger Baum:\n"); printtree(tree); } void log(FILE *file) { if(tree->data!=NULL) // Name vorhanden? { fprintf(file,tree->data); // Name nach stdout schreiben log(tree->r); // Funktion rekursiv für rechtes Element aufrufen log(tree->l); // Funktion rekursiv für linkes Element aufrufen } } int main(int argc,char *argv[]) { FILE *file; // Pointer für Logfile char puffer[64]; // Array für Namens-Eingabe tree=malloc(sizeof(sort)); // Speicher reservieren *tree=init; // initialisieren mit struct sort if(argc!=2) { perror("usage: <program> <logfile>"); exit(EXIT_FAILURE); } file=fopen(argv[1],"a+t"); if(file==NULL) { perror("erro: open file"); exit(EXIT_FAILURE); } while(strcmp(puffer,"qq")!=0) { printf("Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben:\n"); fgets(puffer,64,stdin); puffer[strlen(puffer)-1]=0; if(strcmp(puffer,"qq")!=0) add(tree,puffer); } printf("Hier die Ausgabe für den gesamten Baum:\n"); printtree(tree); log(file); // Baum in die Logfile schreiben fclose(file); return 0; } [/PHP] Also, das Programm sortiert die Namen alphabetisch wie in einem Binärbaum ein. Soll es zumindest, das passiert, wenn ich es ausführe: [PHP] ./tree log.txt Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben: Anna bisheriger Baum: Anna Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben: Bob bisheriger Baum: Bob bisheriger Baum: Bob Bob Geben Sie einen Namen ein. Zum Beenden 'qq' eingeben: qq Hier die Ausgabe für den gesamten Baum: qq qq Speicherzugriffsfehler Er scheint die schon vorhandenen structs in data immer mit der aktuellen Eingabe zu überschreiben, keine Ahnung wieso. Der Speicherzugriffsfehler kommt vom schreiben in die Datei, da haut auch was noch nicht so richtig hin. Sieht jemand warum das Einsortieren nicht funktioniert?

Ok, danke euch beiden! :-)

So ist das also. Mal angenommen, ich hätte keine Berechtigung die Datei zu verändern, könnte ich die Warnung auch wegbekommen, wenn ich was am Quellcode verändere, oder muss die Änderung zwingend in der waehrung.dat vorgenommen werden?

Natürlich, tut mir Leid: "Finnland","SF ","FIM",0.301,0, "Norwegen","N ","NOK",0.238,0, "Schweden","S ","SEK",0.214,0, "Daenemark","DK ","DKK",0.2595,0, "Irland","IRL","IEP",2.46,0, "Grossbritanien","GB ","GBP",2.605,0, "Niederlande","NL ","NLG",0.9035,0, "Frankreich","F ","FRF",0.298,0, "Belgien","B ","BEF",0.048,0, "Tschechien","CS ","CSK",0.062,0, "Oesterreich","A ","ATS",0.144,0, "Schweiz","CH ","CHF",1.143,0, "Ungarn","H ","HUF",0.023,0, "Italien","I ","ITL",0.00108,0, "Spanien","E ","ESB",0.01305,0, "Portugal","P ","PTE",0.011,0, "Griechenland","G ","GRD",0.0082,0, "Tuerkei","TR ","TRL",0.000138,0 [/PHP]

Kleiner Nachtrag: void ausgabe(struct land *L, int s) { int i; for(i=0;i<s;i++) { L[i].verkauf=L[i].umrechnung*0.92; printf("%-30s, %-3s, %-3s,%.4lf,%.4lf\n", L[i].name,L[i].land,L[i].waehrung,L[i].umrechnung,L[i].verkauf); } printf("\n"); } [/PHP] L[i].verkauf hab ich erst später hinzugefügt und die Klammern vergessen. Das Programm macht was es soll, aber die Warnung bleibt. :/ Kann das jemand erklären?

Hallo, ich bekomme vom gcc folgende Warnung, wenn ich meinen C-Code compiliere: gcc pointer2.c -o pointer2 -Wall In file included from pointer2.c:33:0: waehrung.dat: In function ‘main’: waehrung.dat:1:1: warning: missing braces around initializer [-Wmissing-braces] waehrung.dat:1:1: warning: (near initialization for ‘L[0]’) [-Wmissing-braces][/PHP] Leider kann ich damit nichts anfangen. Kann mir jemand erklären woher die Warnung kommt und wie ich sie ausmärzen kann? Hier der Quellcode: [PHP]#include <stdio.h> #include <stdlib.h> #include <string.h> struct land { char name[30+1]; char land[3+1]; char waehrung[3+1]; double umrechnung; double verkauf; }; void ausgabe(struct land *L, int s) { int i; for(i=0;i<s;i++) L[i].verkauf=L[i].umrechnung*0.92; printf("%-30s, %-3s, %-3s,%.4f,%.4f\n" ,L[i].name,L[i].land,L[i].waehrung,L[i].umrechnung,L[i].verkauf); } int compare(const void *p1,const void *p2) { return strcmp( ((struct land *)p1)->name,((struct land *)p2)->name ); } int main() { struct land L[]= { #include "waehrung.dat" }; int s=sizeof(L)/sizeof(struct land); ausgabe(L,s); qsort(L,s,sizeof(struct land),compare); ausgabe(L,s); return 0; }

Achso war das gemeint. Ich hatte nicht verstanden, dass du den Parameter damit meintest, metux. pthread_attr hatte ich aus dem Beispiel in der man-page genommen. Das war sehr verwirrend, daher hab ich da nicht ganz durchgesehen. Mein Prof hatte mir heut auch nochmal erzählt, dass das letzte Argument als Pointer an die Funktion übergeben wird... nur warum vom Typ void und nicht vom Typ char? (siehe man-page) Dass der dritte Parameter als void* übergeben wird, sehe ich ja noch ein, aber warum auch als Parameter? char wäre doch auch nicht unlogisch, oder? Gruß

Ich versteh nicht ganz, was du damit sagen willst. Alle Parameter, die in Klammern stehen, werden an eine Funktion übergeben. Abgesehen davon ist der letzte Parameter bei mir ohnehin NULL. Gruß

Guten Abend, ich versuche mich grade an pthreads. Ich finde die Syntax recht eigenartig muss ich sagen. Das erstellen eines threads funktioniert soweit. Nun möchte ich aber mein argv[1] an meinen erstellten thread übergeben und ausgeben lassen und dieser thread soll wieder irgednwas zurückgeben an das Hauptprogramm. In der man-page steht, dass ich dazu pthread_attr_init brauche und die Adresse als Argument an die Funktion pthread_create übergebe, nur ist der Beispielcode in der man-page echt gewaltig und ich kann nicht ganz nachvollziehen was sort passiert, bzw. verstehe ich es teilweise nicht. Wie kann ich beispielsweise meinen string aus argv[1] an meinen thread übergeben? Ich habe außerdem die Stellen, die mir etwas schleierhaft sind, mit Kommentaren versehen. Hier erstmal mein code: #include <stdio.h> #include <stdlib.h> #include <pthread.h> //#define MAXITER 200000 //wozu ist das gut? void *thread_a(void *arg) { printf(" World!\n"); pthread_exit(NULL); } int main(int argc, char *argv[]) { pthread_t id; pthread_attr_t atr; int ret; if(argc!=2) { fprintf(stdout,"Error: parameter number\n"); exit(EXIT_FAILURE); } pthread_attr_init(&atr); // das scheint mir recht überflüssig, da mein atr doch bereits // vom typ pthread_attr_t ist...warum initialisieren, wenn ich es // ohnehin nur erstelle um es als Parameter zu übergeben? printf("Hello,"); ret = pthread_create(&id, NULL, (void*) &thread_a, NULL); // immer (void*), oder hängt es vom thread ab? if(ret!=0) { perror("creating 1st thread"); exit(EXIT_FAILURE); } pthread_join(id,NULL); exit(EXIT_SUCCESS); } [/PHP] Vielleicht hat ja jemand den Elan sich das mal anzusehen. Am wichtigsten wäre mir zu wissen, wie ich meinen string in den thread bekomme. Danke im voraus! Gruß, Steven

Mein Gott, was fürn dummer Fehler :upps if(ret == -1); Wie soll das denn auch funktionieren, interessant, dass kein Fehler und auch keine Warnung beim Kompilieren kam.

Hallo, ich bastle grad an nem Programm rum um mich mit pipe() auseinanderzusetzen. Ich dachte eigentlich, dass ich fork() verstanden habe, aber nachdem fork() ausgeführt wurde(erfolgreich), läuft der Rest des Programms nicht weiter: #include <stdio.h> // Funktionen für die Ausgabe nach stdout #include <stdlib.h> // für EXIT_FAILURE udn EXIT_SUCCESS #include <string.h> // für strlen() #include <unistd.h> // für pipe() und fork() #define READIDX 0 // Pipe am der Stelle 0 ist der Lesekanal #define WRITEIDX 1 // Pipe am der Stelle 0 ist der Schreibkanal char msg[]="Hallo viele Grüße und so...\n"; int main() { int pipefd[2], getmsg, ret, c; char puffer[120]; ret=pipe(pipefd); // pipe erzeugen if(ret == -1) // prüfe auf Erfolg { perror("pipe"); exit(EXIT_FAILURE); // Beendigung bei Misserfolg } ret=fork(); // rufe fork() auf printf("%d\n",ret); if(ret == -1); // Prüfen auf Erfolg { perror("fork"); exit(EXIT_FAILURE); // Beendigung bei Misserfolg } printf("%d\n",ret); //für den Sohn: if(ret==0) { close(pipefd[WRITEIDX]); //1 ist write, da Vater sendet (also write), macht der Sohn write dicht c=0; // Zähler für das Füllen des Array beim Lesen; c wird nru angelegt, wenn es der Sohn ist do { getmsg=read(pipefd[READIDX], &puffer[c],1); // Lesen der Pipe pipefd auf dem Lesekanal auf der Speicheradresse // von puffer an der Stelle c speichern (immer nur ein Zeichen) if(getmsg==-1) // bei Misserfolg { perror("read from pipe"); // Fehlermeldung exit(EXIT_FAILURE); // Beenden mit Rückgabewert für den Fehlerfall (Betriebssystemabhängig) } c++; } while(getmsg!=0); // solange etwas mit read gelesen wird printf("Vater sendet folgende Nachricht an den Sohn:\n %s",puffer); // Schreiben der Nachricht nach stdout close(pipefd[READIDX]); // read-Pipe schließen exit(EXIT_SUCCESS); } else // für den Vater { close(pipefd[READIDX]); // Lese-Pipe schließen write(pipefd[WRITEIDX],msg,strlen(msg)+1); // Senden der Nachricht in msg über write-Pipe der Länge msg+1 close(pipefd[WRITEIDX]); // Schließen der write-Pipe exit(EXIT_SUCCESS); // Beenden } } [/PHP] Kompilieren läuft sauber durch. Meine Ausgabe: [PHP]# ./pipe 26036 0 fork: Success fork: Success Warum gibt fork Erfolg zurück? Das hab ich doch garnicht angegeben. oO Komischerweise ist das hier meine Ausgabe, wenn ich die Fehlerbehandlung für fork() auskommentiere: 26149 0 Vater sendet folgende Nachricht an den Sohn: Hallo viele Grüße und so...[/PHP] Bin ich der kleinen Menge Eierlikör von grade zum Opfer gefallen? Also das versteh ich grad echt nicht. Warum geht es, wenn ich die Fehlerbehandlung auskommtiere? Diese greift doch nur, wenn ret == -1 ist und genau das hab ich mir doch zuvor ausgeben lassen, es dürfte doch ohnehin nicht in die if-Anweisung gehen, also sollte das selbe passieren, als wie wenn ich es auskommtiere. Was läuft denn hier falsch? Ich wäre echt dankbar für eine Erklärung! Gruß, Steven

ja, nun kommt langsam licht in`s dunkel, vielen dank euch beiden

Hallo, ich möchte malloc in einem Programm verwenden, aber ich versteh nicht ganz wie ich es anwenden soll. In der man-page steht: void *malloc(size_t size); heißt das ich muss malloc als Funktion verwenden? Als Beispiel habe ich zum Beispiel das hier gefunden: #include <stdlib.h> #include <stdio.h> int *zeiger; zeiger=malloc(sizeof(*zeiger) * 10); // Speicher anfordern if (zeiger == NULL) { perror("Nicht genug Speicher vorhanden."); // Fehler ausgeben exit(EXIT_FAILURE); // Programm mit Fehlercode abbrechen }[/PHP] Was passiert denn hier? Ich lege einen Zeiger vom Typ int an und die Variable Zeiger wird mit der Größe des Zeigers * 10 belegt? Vor allem die if-Abfrage ist komisch, wann ist Zeiger denn NULL? Was hat das mit dem angeforderten Speicher zu tun? Kann mir das jemand erklären? Vielleicht anhand eines überschaubareren Beispiels? Vielen Dank!

Jaa, jetzt ist der Groschen gefallen, natürlich:upps fflush(stdout); ist ja echt genial, danke für die Hilfe! Jetzt funktioniert split() auch :-)

Also entry ist eine Struktur, die ich selbst definiert habe, vom Typ DIR. Weil ich auf eine Komponente von DIR zugreife, über einen Pointer auf die Komponente d_name zugreife, verwende ich "->". d_name selbst müsste ein char_array sein...ich hoffe, ich hab jetzt keinen Mist geschrieben ^^`` Also so, wie ich es jetzt nochmal verändert habe, soll es false ergeben, wenn er die letzten 20 Zeichen des Namen abgearbeitet hat (weil ich einfach festlege, dass es keine extension geben wird, die länger als 19 Zeichen ist) oder, wenn l den wert 1 erreicht (beispiel: "backrezept"; a ist das letzte Zeichen, welches überprüft wird, weil der Punkt ja mindestens an 2. Stelle sein muss z.B.: a."out") Naja, wenn ein Punkt gefunden wird, dann verlasse ich die Schleife einfach mit break, nachdem ich die Position des Punktes gespeichert habe... Es wäre bestimmt sauberer, wenn ich das mit in die Schleifen-Bedingung packe, oder? Wie Recht du hast...:upps Stimmt ja, nur war mir bisher nie klar, wann das passieren kann. Ist das bei Funktionsaufrufen prinzipiell so, da diese ja ohnehin komplett an die main weitergegeben werden, wenn sie fertig sind?

Stimmt, das hab ich garnicht gesehen, danke dir! Dass l nicht bei -1 anfangen soll versteh ich (an der Stelle hatte ich lenght erst später hinzugefügt und vergessen es in die Schleife zu nehmen), nur was meinst du mit l>l-20 ? Dass das die einzige Abbruchbedingung ist? Dann würde ich es verstehen, ich hab den Schleifenkopf jetzt geändert: for(l=lenght-1;l>l-20 || l!=1;l--) Aber der Speicherzugriffsfehler ist immernoch da, immerhin wird ja auch nicht "aa" ausgegeben von meiner printf-Anweisung. Also muss doch theoretisch die Übergabe der Variable an split oder die ganze Funktion selbst nicht funktionieren. Oder liege ich da falsch?

Guten Morgen, ich habe schon wieder einen Speicherzugriffsfehler in einem Programm :/ Das Programm soll einen Pfad als Parameter entgegen nehmen, die extension vom restlichen Namen trennen und im restlichen Namen alle Zeichen, die kein alnum sind bzw kein "-" oder "_" sind, durch "_" ersetzen. Kompilieren funktioniert, aber beim Ausführen bekomme ich einen Speicherzugriffsfehler. Ich habe überall printf-Anweisungen eingebaut, weil ich dachte, ich könnte den Fehler eingrenzen, nun weiß ich dadurch zwar wo der Fehler sein soll, aber nicht wo er herkommt ... Hier erstmal der code: #include <stdio.h> #include <dirent.h> #include <errno.h> #include <string.h> #include <sys/stat.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> typedef struct content //hier stehen die getrennten zeichenketten { char base[64]; char extension[20]; }content; void split( struct content *c, char *a ) //funktion zum trennen { printf("aa"); int i=0, pointpos=0; int lenght=0; int l=0, k=0; lenght=strlen(a); for(l-=1;l>l-20;l--) { printf("a"); if(a[l] == '.') { printf("b"); pointpos=l; while(pointpos<lenght) { c->extension[k]=a[l]; k++; l++; } break; } } for(i=0;i<pointpos;i++) { c->base[i]=a[i]; } c->base[i]=0; } void kill(char *a) { int lenght=0,i=0; lenght=strlen(a); for(i=0; i<lenght; i++) { if(a[i] == '-' || a[i] == '_' || isalnum(a[i])) continue; else { a[i]='_'; } } } int main(int number, char *para[5]) { struct content c; //int a=0; //int i =1; char neu[64]; //int lang=0; DIR *directory; struct dirent *entry; directory = opendir(para[1]); //struct dirent info; while((entry=readdir(directory)) != NULL) { if(strcmp(entry->d_name,".") != 0 && strcmp(entry->d_name,"..") != 0 ) { printf("1\n"); split(&c,entry->d_name); //aufteilen des namen in base und extension printf("2 \n"); kill(c.base); //unzulässige zeichen entfernen printf("3 \n"); strcpy(neu,c.base); //kopieren der base in neu printf("4 \n"); strcat(neu,c.extension); //anfügen der extension an neu printf("5 \n"); if(rename(entry->d_name,neu) == 0) printf("%s umbenannt in %s \n",entry->d_name,neu); else perror("rename"); } } return 0; } [/PHP] und das ist die Ausgabe: [PHP] # ./rename . 1 Speicherzugriffsfehler Kann mir jemand sagen, was ich falsch gemacht hab? Vielen Dank!

Wäre mir neu, dass es für verschiedene Schlüsselgrößen anders funktioniert. http://cr.yp.to/antiforgery/cachetiming-20050414.pdf und hier

Ah, natürlich, vielen Dank! Es funktioniert^^ Komisch, mein Prof hat gestern erzählt, wenn eine Variable nicht initialisiert wird, dann wird sie automatisch mit 0 belegt, damit man sich keine Informationen über das, was zuvor im Speicher gestanden hat, holen kann... das ist hier wohl nicht passiert?

Das Thema hab ich ja ganz vergessen. So funktioniert es: #include <stdio.h> #include <sys/types.h> #include <dirent.h> #include <errno.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <unistd.h> int i = 0; int size = 0; int main(int zahl, char *para[1]) { DIR *verzeichnis; struct dirent *eintrag; verzeichnis = opendir(para[1]); struct stat info; if(zahl != 2) { printf("Fehler bei der Parameteruebergabe.\n"); printf("Es muss genau ein Parameter uebergeben werden!\n"); printf("Die Syntax lautet: `./parameter /ordner/ordner/.../ordner`\n"); return 0; } while((eintrag = readdir(verzeichnis)) != NULL) { lstat(eintrag->d_name, &info); //lstat braucht den Name und gibt alles an info weiter if(S_ISREG(info.st_mode)) { printf("%-25s", eintrag->d_name); //oder (*eintrag).d_name, () weisen an, dass erst dereferenziert werden muss i++; size = size + info.st_size; printf("Rueckgabe von d_type: %3d ",eintrag->d_type); printf("size der datei: %8d Byte ",info.st_size); printf("size-gesamt: %9d Byte\n",size); } } printf("\n%d Einträge gefunden\n",i); return 0; } [/php] Danke für die Hilfe!

Das ging ja schnell, danke! :-) An welcher Stelle denn? In der main hab ich es in der 2. Zeile initialisiert und der void übergebe ich es doch?

Hallo, ich hab mir ein kleines C-Programm geschrieben um den Umgang mit Funktionen und Strukturen zu lernen, aber ich bekomme einen Speicherzugriffsfehler. Sieht jemand wo das Problem liegt? Danke im Voraus. :confused: #include <stdio.h> #include <stdlib.h> #include <string.h> struct stadt { int baumzahl; int strassenzahl; struct //struktur in der struktur { int kinder; int etagen; char namehund[32]; }haus; }; void ausgabe( struct stadt A, int i ) //das soll die Funktion sein, die ich in der schleife aufrufe { printf("Ausgabe von Stadt Nr.: %d \n",i ); printf("Es gibt %d Bäume und %d Strassen \n",A.baumzahl, A.strassenzahl ); printf("Im Haus gibt es %d Kinder, %d Etagen und der Hund heißt %s \n",A.haus.kinder, A.haus.etagen,A.haus.namehund); } int main() { printf("1"); int i; struct stadt reise[4]={ {230,10,{2,3,"Bello"}}, {1290,70,{7,4,"Hasso"}}, {2000,9,{1,4,"Goofy"}}, {40,340,{2,3,"Flash"}} }; printf("2"); while ( i != 4 ) { printf("3"); ausgabe( reise[i], i ); i++; } printf("Ende\n"); return 0; } [/php]