Feld mit Strucktur an Funktion übergeben und dann zurückge

[Marco (Gast)]

Hallo

Ich möchte mit C ein Feld mit einer Strucktur in einer Funktion füllen 
lassen und dann zurückgeben.
Leider bekomme ich es nicht geschossen.

Angenommen das Feld sieht so aus:

person[0].name
person[0].vorname
person[0].ort

wie kann ich das in eine Funktion übergeben, dort mit werten füllen und 
zurückgeben?

Danke.

[Rufus Τ. F. (rufus)]

Willst Du nur eine Instanz der Struktur übergeben oder ein Array von 
Strukturen?

struct mystruct
{
  char name[80];
  char vorname[80];
  char ort[80];
};


void funktion_die_was_macht(void)
{
  struct mystruct variable;

  fuelle_struktur(&variable);
}

void fuelle_struktur(struct mystruct *p)
{
  strcpy(p->name, "Doe");
  strcpy(p->vorname, "Jane");
  strcpy(p->ort, "Nirvana");
}

Wird ein Array von Strukturen verwandt, sieht die Angelegenheit kaum 
anders aus:

void funktion_die_was_macht(void)
{
  struct mystruct array[10];
  int i;

  for (i = 0; i < 10; i++)
    fuelle_struktur(array + i);

  // oder
  fuelle_struktur(&array[4]);
}

Die aufgerufene Funktion bleibt unverändert, nur die Syntax beim Aufruf 
ändert sich.


Kauf Dir ein C-Buch. Kernighan & Ritchie, "Programmieren in C", zweite 
Auflage, Hanser-Verlag.

[Marco (Gast)]

Puh, das ist ja aufwendiger als ich dachte.
Das muß ich mir heute Abend mal in Ruhe angucken.

Ich möchte eine Array von Strukturen in eine Funktion übergeben, dort 
mit Werten füllen und dann zurückgeben.

[Rainer I. (raih)]

Du kannst auch einen Pointer auf das gesamte Array und dessen Größe 
übergeben

void funktion_die_was_macht(void)
{
  struct mystruct array[10];
  int i;

  fuelle_struktur(&array, sizeof(array)/sizeof(mystruct) );
}

void fuelle_struktur(struct mystruct *p, int entrys )
{
  int i;
  for (i = 0; i < entrys ; i++,p++)
  {
    strcpy(p->name, "Doe");
    strcpy(p->vorname, "Jane");
    strcpy(p->ort, "Nirvana");
  }
}

Evtl. sind noch ein paar typecasts erforderlich

[Rufus Τ. F. (rufus)]

Das '&' beim ersten Argument des Aufrufs von fuelle_struktur kann 
entfallen. Die Division lässt sich auch einsparen, wenn die [10] durch 
ein #define ersetzt wird. Außerdem fehlt bei "sizeof (mystruct)" das 
Schlüsselwort "struct", das ist nur in C++ nicht erforderlich.

Ganz penible bilden den korrekten englischen Plural von "entry" -> 
"entries".

[yalu (Gast)]

> Die Division lässt sich auch einsparen, wenn die [10] durch ein
> #define ersetzt wird.

Die Division stört nicht, die macht der Compiler. Die Bestimmung der
Arraygröße mit sizeof ist vor allem bei initialisierten Arrays von
Vorteil, bei denen man die Größe nicht explizit angeben will.

[Karl H. (kbuchegg)]

>
> Die Division stört nicht, die macht der Compiler. Die Bestimmung der
> Arraygröße mit sizeof ist vor allem bei initialisierten Arrays von
> Vorteil, bei denen man die Größe nicht explizit angeben will.

> Außerdem fehlt bei "sizeof (mystruct)" das
> Schlüsselwort "struct", das ist nur in C++ nicht erforderlich.

OK. Besser ist es allerdings das ganze so zu schreiben:

sizeof(array)/sizeof(*array)

Dadurch taucht der Datentyp in der Berechnung der Größe
überhaupt nicht mehr auf.

OK. Bei diesem Beispiel ist das vielleicht nicht wirklich
relevant, da sich der Datentyp von Array kaum ändern wird.
Aber hier geht es um die Gewöhnung an Coding Standards und
defensives Programmieren.

Nehmen wir den Fall

   int a[20];
   ...
   int j = sizeof(a) / sizeof(int);

ist zunächst mal richtig.
Jetzt kommt der Programmierer auf die glorreiche Idee,
dass ihm int nicht reicht und er das Array als double
Ausführen möchte.

Nur: Wie es der Teufel haben will, vergisst er auf die
Anpassung in der Größenberechnung (das kann schon mal
passieren, wenn Code größer wird)

  double a[20];
  ...
  int j = sizeof(a) / sizeof(int);

Kein Compiler kann diesen Fehler entdecken und glaub mir:
An solchen Sachen sucht man lange.

Hingegen

   int a[20];
   ...
   int j = sizeof(a) / sizeof(*a);

ist richtig

   double a[20];
   ...
   int j = sizeof(a) / sizeof(*a);

ist auch richtig.
Durch die Schreibweise kann ich den vorhergehenden Fehler
einfach nicht mehr machen -> ein vermeidbarer Fehler ist kein
Problem mehr.