GCC: invalid use of flexible array member

[Sebastian Schildt (Gast)]

Hallo!

Ich habe ein kleines Problem mit dem GCC (WinAVR). Vermutlich liegt es
eher an meinen C-Kenntnissen als an GCC :).

Gegeben sind folgende structe:
---------------------
struct artsProcess {
  uint8_t pid;
  uint8_t state;
  uint8_t numStates;
  struct artsTransition * transitions[]; /*Array of artsTrans, für jeden
State eine Kette von Trans*/
 };

 struct artsTransition {
   uint8_t srcPid;
   uint8_t sigID;
   struct artsTransition * next;
   void (*exec)(struct artsSignal* signal);
 };
--------------------------

Folgendes geht nicht:
tempProc->transitions=malloc(BLINK_NUMSTATES*sizeof(struct
artsTransition));

(tempProc ist ein artsProcess )

Der GCC sagt: blinkLED.c:23: error: invalid use of flexible array
member

Was bedeutet das? Da "transisitons" ein Zeiger auf ein Array ist,
versucht ich soviel Speicher zu reservieren wie ich artsTransition
Objekte brauche (BLINK_NUMSTATES).

Wie mache ich das, bzw. warum geht es soch nicht?

MfG

Sebastian

[Jörg Wunsch (Gast)]

Geh zurück zu K&R, Kapitel `Pointer and Arrays'.  Du hast das noch
nicht verstanden. ;-)

Du kannst dafür kein Array benutzen, sondern mußt das alles über
Zeiger deklarieren (und für diese dann passend Speicher anfordern).

Ich blicke nicht ganz durch, ob das geschachtelt werden soll oder ein
simples Array; im letzteren Fall genügt ein simpler Zeiger,
andernfalls brauchst Du u. U. einen doppelt indirekten.

[Sebastian Schildt (Gast)]

Hallo!

Ne, doppelt geschachtelt ist das nicht. Es ist ein Array of structs.
(Das die Structe selber wieder ne verkettete Liste sind ist ja hierbei
an sich egal).

Ich werde mir das Kapitel wohl besser noch mal reinziehen. Ich habe es
umgebastelt, so dass der Zeiger im "artsProcess" jetzt so deklariert
ist

struct artsTransition * transitions

Das funktioniert auch, das Problem ist nur, dass ich wenn ich an diesen
Zeiger ein ganzen Array "hänge", ich wohl per Zeigerarthmetik auf die
hinteren Elemente zugreifen muss, in der Art:

zeigerAuf2=zeigerAuf0+(2*sizeof(artsTransition))

oder so ähnlich. Das finde ich ziemlich hässlich. Schöner wäre es wenn
ich trotzdem irgendwie wieder die eckigen Klammern "[]" bekommen
könnte.

Das kann jetzt Müll sein, was ich hier schreibe, aber so scheint es zu
gehen. Werde morgen erstmal Kapitel 5 lesen.

MfG

Sebastian

[Jörg Wunsch (Gast)]

> Schöner wäre es wenn ich trotzdem irgendwie wieder die eckigen
> Klammern "[]" bekommen könnte.

Eben deshalb sollst Du ja zum K&R zurückgehen.  Genau das geht in C
auch mit Zeigern.

[Sebastian Schildt (Gast)]

Moin!

Danke, es funzt (ok, du hast nur gesagt ich soll nochmal lesen, aber
das war genau das richtige :) ).

Wie prophezeit, habe ich im 2. Post Mist erzält, wenn auch woanders als
gedacht: Bei Zeigerarithmetik heißt "+1" wohl immer "soviel wie der
Typ lang ist addieren", also kann man sich sizeof sparen.

Für Mitleser nochmal in Kürze, was geht:

//Zeiger auf ein int(array beliebiger Größe)
int *test;

//Platz für einen 10 Einheiten langen Vektor schaffen
test = malloc(10*sizeof(int));

//Zugriff auf Element 3
int elem3 = *(test+3);
//oder
int elem3 = test[3];

Man kann immer +3 schreiben auch wenn ein "int" 256 Bits lang wäre.

Ich hoffe das stimmt so. Eines Tages kann ich auch C....

MfG

Sebastian

[Jörg Wunsch (Gast)]

Hast Du völlig richtig erkannt.  Klar hätte ich Dir das auch gleich
schreiben können, aber so weißt Du jetzt wenigstens auch, warum das so
ist. ;-)