structs

[hame]

wer kann sich hier den code anschaun und mir kurz helfen?

ich habe hier eine vorgegebene struktur und soll mittels array werte einspeicher. am ende soll ich dann die funktion einen zeiger auf den eintrag zurückliefern und der zeiger soll im array gespeichert werden

typedef struct{

char name[50];

char vorname[50];

int plz;

}t_adresse;

t_adresse* eingabe(){

t_adresse *speicher[5];

speicher = malloc(sizeof(t_adresse));

printf("Name eingeben: \n");

fgets(speicher.name,sizeof(speicher.name),stdin);

printf("Vorname eingeben: \n");

fgets(speicher.vorname,sizeof(speicher.vorname),stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher.plz);

}while(getchar() != '\n');

return speicher;

}

die fehlermeldung sagt bei mir das die variablen name, vorname und plz keiner struktur angehören.

[Klotzkopp]

t_adresse *speicher[5];

Warum [5]?

Damit legst du ein Array von 5 Zeigern an.

speicher = malloc(sizeof(t_adresse));

Das sollte schon nicht funktionieren. speicher ist (durch die fehlerhafte Deklaration) ein Array, und Arrays kann man nichts zuweisen.

die fehlermeldung sagt bei mir das die variablen name, vorname und plz keiner struktur angehören.

Wenn du dir nicht hundertprozentig sicher bist, dass du die Fehlermeldung richtig deutest, ist es immer besser, die Fehlermeldung selbst hier reinzustellen, statt deiner Interpretation. Denn auch dabei können schon Fehler unterlaufen. Ich bin ziemlich sicher, dass die Fehlermeldung etwas anderes aussagt.

Das grundlegende Problem ist, dass du -> statt . benutzen musst, wenn du über einen Zeiger auf die Strukturelemente zugreifen willst.

[konsti4u]

Da ist ganz schön was durcheinander, also:

t_adresse *speicher[5];

Damit sagst du, dass speicher ein array der Länge 5 ist, wo jedes Arrayelement auf einen struct t_adresse zeigt, das war so sicher nicht gedacht. Du meinst denk ich mal:

t_adresse* speicher;

speicher = malloc(sizeof(t_adresse));

Nun versuchst du den Namen einzulesen und im speicher->name zu speichern.

fgets(speicher.name,sizeof(speicher.name),stdin);

So geht das nicht, weil speicher nur ein Zeiger ist, den musst du erst dereferenzieren, also:

fgets((*speicher).name,sizeof(speicher.name),stdin);

oder aber andere Schreibweise:

fgets(speicher->name,sizeof(speicher.name),stdin);

Und das gleiche Spiel bei dem Rest, sollte dann gehen (nicht geprüft)

[hame]

Warum [5]?

Damit legst du ein Array von 5 Zeigern an.

Das sollte schon nicht funktionieren. speicher ist (durch die fehlerhafte Deklaration) ein Array, und Arrays kann man nichts zuweisen.

Wenn du dir nicht hundertprozentig sicher bist, dass du die Fehlermeldung richtig deutest, ist es immer besser, die Fehlermeldung selbst hier reinzustellen, statt deiner Interpretation. Denn auch dabei können schon Fehler unterlaufen. Ich bin ziemlich sicher, dass die Fehlermeldung etwas anderes aussagt.

Das grundlegende Problem ist, dass du -> statt . benutzen musst, wenn du über einen Zeiger auf die Strukturelemente zugreifen willst.

5 weil ich maximal 5 einträge speichern will. danach will ich das dynamisch machen aber soweit bin ich ja noch nicht.

beim 2ten punkt wollte ich eigentlich den elementen von der struktur speicher zuweisen^^ und nicht dem array. muss ich jedem elemeten einzeln speicher zuweisen oder kann ich das gleich alles auf einmal machen?

und das mit -> wusste ich nicht. jetzt ist auch die fehlermeldung weg.

[hame]

Da ist ganz schön was durcheinander, also:

t_adresse *speicher[5];

Damit sagst du, dass speicher ein array der Länge 5 ist, wo jedes Arrayelement auf einen struct t_adresse zeigt, das war so sicher nicht gedacht. Du meinst denk ich mal:

t_adresse* speicher;

speicher = malloc(sizeof(t_adresse));

Nun versuchst du den Namen einzulesen und im speicher->name zu speichern.

fgets(speicher.name,sizeof(speicher.name),stdin);

So geht das nicht, weil speicher nur ein Zeiger ist, den musst du erst dereferenzieren, also:

fgets((*speicher).name,sizeof(speicher.name),stdin);

oder aber andere Schreibweise:

fgets(speicher->name,sizeof(speicher.name),stdin);

Und das gleiche Spiel bei dem Rest, sollte dann gehen (nicht geprüft)

ne das war schon so richtg gemeint. nur wollte ich nicht der variable "speicher" speicher zuweisen sondern den elemementen in der struktur ^^

[hame]

typedef struct{

char name[50];

char vorname[50];

int plz;

}t_adresse;

t_adresse* eingabe(){

t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));

printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');

return speicher;

}

jetzt gehts zwar auch nicht aber ich bekomme keine fehlermeldung durch und ich habe keine array wo ich 5 einträge speichern könnte. wie mache ich das? außerdem wollt ich noch fragen ob der rückgabetyp stimmt. es soll ein zeiger auf den eintrag zurückliefern und muss halt auch logischerweise den eintrag im array speicher, aber wie?

[konsti4u]

Also du willst in deinem Array 5 Adressen speichern?

dann lege dir eine variable adressen an welches auf die 5 Adressen zeigt, dementsprechend muss die Rückgabe der Funktion t_adresse** sein, da Pointer auf Pointer:

t_adresse* adressen[5];  /*Braucht man nicht initialisieren, da Größe bekannt (sind nur Pointer) */

int k;


for(k=0; k<5; k++) {

printf("Adresse: %d \n", i);


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


}


return adressen;

}

Nicht getestet!

[hame]

also eigentlich wollte ich 5 adressen in meine struktur speichern. ich sollte mir dazu ein array mit 5 zeigern auf meine struktur erzeugen. und diese funktion schreiben. es heißt halt bevor die funktion den rückgabetyp liefert soll die adresse in dem array gespeichert werden. ich weiß halt nicht ob man das so macht über arrays, dass man die daten dort reinspeichert die in der struktur dann enthalten werden sollen. am ende soll halt in der struktur ein kleines adressbuch sein. ich hätte es halt anders gemacht aber es wird halt verlangt das man sich diesen zeigerarray macht.

[Klotzkopp]

ich sollte mir dazu ein array mit 5 zeigern auf meine struktur erzeugen.

Bist du ganz sicher, dass es kein Zeiger auf ein Array von 5 Strukturen sein sollte? Das wäre der übliche Weg.

[hame]

Bist du ganz sicher, dass es kein Zeiger auf ein Array von 5 Strukturen sein sollte? Das wäre der übliche Weg.

ja aber wenn bei mir steht "legen sie ein array von typ blabla" und dann noch als beispiel "typ *name[5];" dasteht dasnn versteh ich das so.

[konsti4u]

ja aber wenn bei mir steht "legen sie ein array von typ blabla" und dann noch als beispiel "typ *name[5];" dasteht dasnn versteh ich das so.

typ *name[5] ist ein array von diesem Typ, also genau was wir gesagt haben, ein array von adressen, und was in meinem codebeispiel drinsteht x)

t_adresse* adressen[5]

adressen---->speicher---------------------------------->t_adresse

                   speicher---------------------------->t_adresse

                   speicher--//entspricht adressen[2] --> usw

                   speicher  //entspricht adressen[3]

                   speicher  // usw.

[hame]

ja das hat mich verwirrt das bei deinem beispiel der stern beim typen steht und bei dem beispiel was ich gegeben habe der stern bei der variable steht also : bei dir t_adresse* adressen[5] und bei mir t_adresse *name[5]; ist das das selbe?

[konsti4u]

Jap ^^

[hame]

man -.-...

wenn ich jetzt dein codebespiel aufteilen will in eine funktion und eine main wo in der main gefragt wird wieviele adressen ich eingeben will. was muss ich denn der funktion für parameter übergebenw weil sie ja vom typen t_adresse* ist? also in der funktion soll es eingelesen adresse in dem array gespeichert werden.

[konsti4u]

Dann machs so:

static int counter=0; //GLOBALER zähler gestartet bei 0!


int main() {

t_adresse* adressen[5];  //Falls du nicht weißt wie viel du brauchst musst du mit malloc und realloc dynamisch allokieren

eingabe(adressen);

eingabe(adressen);

...

for (int i=0; i<counter; i++) {

printf("%s", adressen[i]->name);

}

}


void eingabe(t_adresse** adressen) {   //void da man nichts zurückgibt sondern nur den übergebenen zeiger benutzt


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


adressen[counter] = speicher;

counter++;

}

//So in der Art, nicht getestet!

[hame]

eine kleine frage. wo kommt denn bei dir das i vor? hast du schon vorher inrgendwo implementiert oder muss man das nicht wenn man diesen globalen zählen schreibt weil ich damit noch nicht gearbeitet habe.

und noch eine kleine frage, also wenn eine funktion nur einen zeiger zurückliefert dann ist es void bzw gibts kein return. sorry wenn ich so dumm frage aber wenn es zeiger geht komm ich leicht durcheinander.

[konsti4u]

Das i habe ich in der for-Schleife initialisiert, das hätte man aber genauso gut am Anfang der main() machen können mit int i;

und dann bei der schleife: for (i=0; i<counter; i++) ...

Der globale Zähler, ist einfach nur eine Variable wie jede andere, deren Inhalt nur nicht beim verlassen einer Methode gelöscht wird (so, wie die üblichen lokale Variablen) und von allen Methoden abgefragt und verändert werden kann.

Man hätte den Code auch ohne der globalen lösen können, indem du die Zahl an die Methode eingabe mit übergibst... würde dann etwas anders aussehen das ganze, aber so dachte ich ist es am einfachsten zu verstehen...

Void heißt gar kein Rückgabewert! Brauche ich in dem Beispiel nicht, ich übergebe der Methode eingabe() einen Zeiger auf Adressen, er nutzt diesen Zeiger um in Adressen eine Adresse einzufügen und damit endet auch die Methode, so muss man auch nichts zurückgeben.

Wenn du es unbedingt mit Rückgabe machen willst/musst, würde das auch gehen... müsste man ebenfalls etwas anpassen, aber finds so schöner

Bearbeitet 13. Dezember 2009 von konsti4u

[konsti4u]

So wärs dann in der Art:

int main() {

t_adresse* adressen[5];  //Array von Zeigern auf Adressen

t_adresse* adresse;  //Zeiger auf Adresse

int i; //Zählervariable



for (i = 0; i<5; i++) {

adresse = eingabe();

adressen[i] = adresse;

}


for (i=0; i<5; i++) {

printf("%s", adressen[i]->name);

}

}


t_adresse* eingabe() {


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


return speicher;

}

[hame]

Das i habe ich in der for-Schleife initialisiert, das hätte man aber genauso gut am Anfang der main() machen können mit int i;

und dann bei der schleife: for (i=0; i<counter; i++) ...

Der globale Zähler, ist einfach nur eine Variable wie jede andere, deren Inhalt nur nicht beim verlassen einer Methode gelöscht wird (so, wie die üblichen lokale Variablen) und von allen Methoden abgefragt und verändert werden kann.

Man hätte den Code auch ohne der globalen lösen können, indem du die Zahl an die Methode eingabe mit übergibst... würde dann etwas anders aussehen das ganze, aber so dachte ich ist es am einfachsten zu verstehen...

Void heißt gar kein Rückgabewert! Brauche ich in dem Beispiel nicht, ich übergebe der Methode eingabe() einen Zeiger auf Adressen, er nutzt diesen Zeiger um in Adressen eine Adresse einzufügen und damit endet auch die Methode, so muss man auch nichts zurückgeben.

Wenn du es unbedingt mit Rückgabe machen willst/musst, würde das auch gehen... müsste man ebenfalls etwas anpassen, aber finds so schöner

das klingt mir jetzt einlechtend ^^.

[hame]

So wärs dann in der Art:

int main() {

t_adresse* adressen[5];  //Array von Zeigern auf Adressen

t_adresse* adresse;  //Zeiger auf Adresse

int i; //Zählervariable



for (i = 0; i<5; i++) {

adresse = eingabe();

adressen[i] = adresse;

}


for (i=0; i<5; i++) {

printf("%s", adressen[i]->name);

}

}


t_adresse* eingabe() {


t_adresse *speicher;

speicher = malloc(sizeof(t_adresse));


printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

do

{

scanf("%i", speicher->plz);

}while(getchar() != '\n');


return speicher;

}

ich glaube da ist der ansatz den ich gehen sollte. nur muss ich ein paar sachen umstellen. weil ich noch fehler bekomme ^^

[hame]

so fast geschafft, er bricht mir nur ab wenn ich zahlen eingebe, wieso? hat es was mit speicherreservierung zu tun?

typedef struct{

char name[30];

char vorname[30];

int plz;

}t_adresse;

t_adresse* eingabe() {

t_adresse *speicher;

speicher = malloc(sizeof(t_adresse*));

printf("Name eingeben: \n");

fgets(speicher->name,50,stdin);

printf("Vorname eingeben: \n");

fgets(speicher->vorname,50,stdin);

printf("Postleitzahl eingeben: \n");

scanf("%i", speicher->plz);

return speicher;

}

main(){

int i;

t_adresse* adressen[5];

t_adresse* adresse;

for (i = 0; i<5; i++) {

adressen = eingabe();

}

}

[konsti4u]

siehe scanf-Benutzung:

Du hast das & vergessen

scanf("%i", &speicher->plz);

MfG

[hame]

ahhh danke, also langsam komme ich mir richtig blöd vor.

[hame]

klappt jetzt wunderbar und wenn ich jetzt den user fragen will wie viele einträge er speichern will dann muss ich doch nur das array der angabe anpassen?

[konsti4u]

Ja genau, und da du das nicht voraus wissen kannst, kannst du das jetzt nicht reincoden, sondern musst den Speicher dann dynamisch allokieren!

z.B:

main(){

int i, j;

printf("Bitte Zahl eingeben: ");

scanf("%i", &j);


t_adresse** adressen=malloc(j * sizeof(t_adresse*));

t_adresse* adresse;


for (i = 0; i<j; i++) {

adressen[i] = eingabe();

}


//Und immer schön alles freen am Ende 

for (i = 0; i<j; i++) {

free(adressen[i]);

}

free adressen;

}

[/code]