Struktur + malloc

bahanfar

Hallo,

wie kann ich in HEADER-Struktur für myStruct bzw. test zur Laufzeit dynamisch Speicher allokieren?
*myStruct war vorher myStruct[5], aber jetzt weiß ich nicht welche Anzahl von Strukturen in union.
Folgendes überschreibt die HEADER-Struktur in einer Schleife, was nich gewollt ist.
Wie muss ich Programmieren, damit ich am Ende header.entry_info.myStruct[n] Array habe?

Danke,
Bahanfar

HEADER header;
header.entry_info.myStruct = (MY_STRUCT *)malloc(sizeof(MY_STRUCT));

typedef struct TEST
{
int a;
}TEST;

typedef struct MY_STRUCT
{
int b;
int c;
}MY_STRUCT;

typedef struct HEADER
{
union {
MY_STRUCT *myStruct;
TEST *test;
}entry_info;

}HEADER;

mcr

Hi,

erstmal: ich würde die typedef's folgendermaßen definieren:

typedef struct {
    int a;
} TEST;

typedef struct {
    int b;
    int c;
} MY_STRUCT; 

typedef struct {
    union {
        MY_STRUCT *myStruct;
        TEST *test;
    } entry_info;
} HEADER;

um nun speicher zu allozieren verwendet man malloc:

MY_STRUCT *a = malloc(sizeof(MY_STRUCT));

Um sich ein "Array" zu definieren -- ich weiß, es ist kein wirkliches Array --
macht man folgendes:

MY_STRUCT *b = malloc(10*sizeof(MY_STRUCT));

Mit diesem Befehl wird ein "Array" mit 10 Elementen angelegt.
Zugreifen kannst du dann mit:

b[4].c = 10;

oder eines der folgenden:

(b+4)->c = 10;
(*(b+4)).c = 10;

Ich hoffe, das hat dir jetzt helfen können.
Gruß mcr

bahanfar

mcr schrieb:

Hi,

erstmal: ich würde die typedef's folgendermaßen definieren:
typedef struct {
    int a;
} TEST;

typedef struct {
    int b;
    int c;
} MY_STRUCT; 

typedef struct {
    union {
        MY_STRUCT *myStruct;
        TEST *test;
    } entry_info;
} HEADER;
um nun speicher zu allozieren verwendet man malloc:
MY_STRUCT *a = malloc(sizeof(MY_STRUCT));
Um sich ein "Array" zu definieren -- ich weiß, es ist kein wirkliches Array --
macht man folgendes:
MY_STRUCT *b = malloc(10*sizeof(MY_STRUCT));
Mit diesem Befehl wird ein "Array" mit 10 Elementen angelegt.
Zugreifen kannst du dann mit:
b[4].c = 10;
oder eines der folgenden:
(b+4)->c = 10;
(*(b+4)).c = 10;
Ich hoffe, das hat dir jetzt helfen können.
Gruß mcr

Hallo,
Danke für die Antwort. Das Problem ist, dass ich die Anzahl der Array (Strukturen) vorher nicht kenne. In einem Schleifendurchlauf, kommen die Strukturen in union (sind eigentlich 10 Stück), in beliebiger Reihenfolge vor, sodass ich zu Schluß z. B. 3 mal myStruct habe und 5 mal test. Man könnte schon vor der Schleife, für gößere Struktur maximal mögliche Struktur-Array zur Verfügung stellen. Das soll aber möglichst vermieden werden.
Kann sein, dass dynamisch übrehaupt nicht geht?
Grüße
Bahanfar

CStoll

Dann machst du halt keine union von Zeigern (bei dem Aufbau kannst du entweder nur MY_STRUCT's ablegen oder nur TEST's), sondern ein Array von unions.

(btw, dir ist klar, daß du selber verwalten mußt, welcher union-Anteil gerade gültig ist?)

mcr

Sowie ich dich jetzt verstehe, möchtest du mit einem HEADER gleichzeitig
TEST als auch MY_STRUCT speichern. Dafür ist aber eine union nicht
geeignet.

Union verwendest du immer dann, wenn du entweder das eine oder das andere
speichern möchtest, aber trotzdem die Flexibilität haben möchtest, nur einen
Typ zu übergeben.

du bräuchtest dann:

typedef struct {
    unsigned int num_my_structs, num_tests;
    MY_STRUCT *my_struct;
    TEST      *test;
} HEADER;

Wenn du allmählich die Größe der "Arrays" verändern möchtest, kannst du wie folgt vorgehen:

MY_STRUCT *neu = malloc(neue_anzahl * sizeof(MY_STRUCT));
    memset(neu, 0x0, neue_anzahl*sizeof(MY_STRUCT));
    memcpy(neu, alt, alte_anzahl*sizeof(MY_STRUCT));
    free(alt);

Oder du verwendest realloc();

Gruß mcr

bahanfar

mcr schrieb:

Sowie ich dich jetzt verstehe, möchtest du mit einem HEADER gleichzeitig
TEST als auch MY_STRUCT speichern. Dafür ist aber eine union nicht
geeignet.

Union verwendest du immer dann, wenn du entweder das eine oder das andere
speichern möchtest, aber trotzdem die Flexibilität haben möchtest, nur einen
Typ zu übergeben.

du bräuchtest dann:
typedef struct {
    unsigned int num_my_structs, num_tests;
    MY_STRUCT *my_struct;
    TEST      *test;
} HEADER;
Wenn du allmählich die Größe der "Arrays" verändern möchtest, kannst du wie folgt vorgehen:
MY_STRUCT *neu = malloc(neue_anzahl * sizeof(MY_STRUCT));
    memset(neu, 0x0, neue_anzahl*sizeof(MY_STRUCT));
    memcpy(neu, alt, alte_anzahl*sizeof(MY_STRUCT));
    free(alt);
Oder du verwendest realloc();

Gruß mcr

Hi,
Union ist schon richtig, es ist also schon beabsichtigt, pro Durchlauf eine Struktur zu nehmen. Wie CStoll geschrieben hat, muss ich wohl Array von unions verwenden.
Danke euch
Bahanfar

bahanfar

CStoll schrieb:

Dann machst du halt keine union von Zeigern (bei dem Aufbau kannst du entweder nur MY_STRUCT's ablegen oder nur TEST's), sondern ein Array von unions.

(btw, dir ist klar, daß du selber verwalten mußt, welcher union-Anteil gerade gültig ist?)

Hallo,
muß Array von unions bestimmte Länge haben? Folgendes geht nicht, außer Array-Anzahl fest ist. Oder mache ich was falsch?

struct HEADER
{
int msb;

union
{
MY_STRUCT myStruct;
TEST test;
}entry_info[];

union
{
int a;
float b;
double c;
}test[];

}typedef HEADER;

Danke

mcr

Hi,

vorweg erstmal: BITTE verwende cpp-Tags, wenn du Code postest.
Deine Postings sind ziemlich bescheiden zu lesen!
Außerdem brauchst du nicht die ganzen Postings zitieren. Wir können
schon selbst nach oben blättern!

So, nun zu deinem Problem:
Vielleicht hilft dir das hier weiter.

typedef union {
    MY_STRUCT *my_struct;
    TEST      *test;
} ENTRY;

typedef struct {
    int msb;
    ENTRY *entry_info;
} HEADER;

Zum "Array"-Allozieren verwende:

HEADER head;
head.entry_info = malloc(anzahl * sizeof(ENTRY));

Zugriff mit:

head.entry_info[i].my_struct.c = 10;

Gruß mcr

PS: ich würde es anders lösen. Dies finde ich nicht wirklich elegant.
Es geht bestimmt auch ohne unions.

Vielleicht noch abschließend eine WARNUNG:
So wie CStoll schon schrieb: du musst dich selbst um die Verwaltung
von entry_info kümmern. Irgendwo musst du dir speichern, ob
entry_info[i] nun ein MY_STRUCT* oder TEST* beinhaltet.

CStoll

@mcr: Da würde ich in der union die Sternchen weglassen - sonst mußt du außer für das gesamte Array auch noch Platz für jedes einzelne Element anfordern (und verwalten).

@bahanfar: Jedes Array muß eine vorgegebene Länge haben. Wenn du erst zur Laufzeit weißt, wie lang das Array werden soll, brauchst du Zeiger:

typedef union
{
  MY_STRUCT my_struct;
  TEST      test;
} entry;

...
entry* array = malloc(anzahl*sizeof(entry));