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

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

1

struct mystruct

2

{

3

  char name[80];

4

  char vorname[80];

5

  char ort[80];

6

};

7

8

9

void funktion_die_was_macht(void)

10

{

11

  struct mystruct variable;

12

13

  fuelle_struktur(&variable);

14

}

15

16

void fuelle_struktur(struct mystruct *p)

17

{

18

  strcpy(p->name, "Doe");

19

  strcpy(p->vorname, "Jane");

20

  strcpy(p->ort, "Nirvana");

21

}

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

1

void funktion_die_was_macht(void)

2

{

3

  struct mystruct array[10];

4

  int i;

5

6

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

7

    fuelle_struktur(array + i);

8

9

  // oder

10

  fuelle_struktur(&array[4]);

11

}

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.

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

1

void funktion_die_was_macht(void)

2

{

3

  struct mystruct array[10];

4

  int i;

5

6

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

7

}

8

9

void fuelle_struktur(struct mystruct *p, int entrys )

10

{

11

  int i;

12

  for (i = 0; i < entrys ; i++,p++)

13

  {

14

    strcpy(p->name, "Doe");

15

    strcpy(p->vorname, "Jane");

16

    strcpy(p->ort, "Nirvana");

17

  }

18

}

Evtl. sind noch ein paar typecasts erforderlich

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".

>
> 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:

1

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

1

   int a[20];

2

   ...

3

   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)

1

  double a[20];

2

  ...

3

  int j = sizeof(a) / sizeof(int);

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

Hingegen

1

   int a[20];

2

   ...

3

   int j = sizeof(a) / sizeof(*a);

ist richtig

1

   double a[20];

2

   ...

3

   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.