4. Dynamische Struktur mit dynamischen Array

Dynamische Struktur mit dynamischen Array

  • B

    Hallo

    Ich hätte wüsste gern wie ich das programmieren soll:

    typedef struct Dyn_struct
    {
    float *Dyn_float;
    int anzahl_der_Dyn_float_eingaben;
    }

    Vielleicht weiss ja jemand wie das geht.

    0
  • U

    ämmm, ich weis ja nich ob ich heut schon ein wenig müde bin (trotz 4 kaffe) aber ich steig nich ganz durch was dein eigentliches Problem ist.

    Kannst nich noch ein paar zeilen schreiben, die dein Problem etwas genauer umreisen.

    Gruss

    ...uncle sam

    0
  • B

    Ich frag mich wie ich die Deklaration, also Speicher reservieren für struct und das float array machen soll, und dann später darauf zugreifen.
    Die Deklaration von struct soll so aussehen wie ich es geschrieben hab.

    0
  • W
     

    struct DynArray
{
    double *YAnzahl;
};

typedef struct DynArray DArray;

DArray *XAnzahl;
XAnzahl=(DArray *)calloc(XAbzissen, sizeof(DArray));
for(unsigned int ctr=0; ctr<YAbzissen;ctr++) XAnzahl[ctr].YAnzahl=(double *)calloc(YAbzissen, sizeof(double));

    Besser ist aber wenn Du zweidimensionale Strukturen versuchst auf eindimensionale abzubilden, diese haben den Vorteil, daß sie "wesentlich" schneller sind.

    double *XYFlaeche;
XYFlaeche=(double *)calloc(XY, sizeof(double));
#define f(x,y) XYFlaeche[MaxX*y + x];

    Gruß Winn

    0
  • ?

    @beeblomarv,

    ich hoffe ich habe dich richtig verstanden.

    #include <malloc.h>

typedef struct structDYN
{
  float *pFloats;
  int iAnzahl;
} DYN;

DYN dyn; /* Struktur erstellen */

/* Speicher für 10 float-Werte reservieren */
dyn.iAnzahl = 10;
dyn.pFloats = malloc( sizeof( float ) *dyn.pFloats );

dyn.pFloats[0] = 0.125; /* Auf 1. float-Wert zugreifen */
dyn.pFloats[0] = 1.500; /* Auf 2. float-Wert zugreifen */
...

/* Wenn die Struktur nicht mehr benötigt wird muss 
   der reservierte Speichere wieder freigegeben werden*/
free( dyn.pFloats );

    Bye Peter.

    0
  • R

    Original erstellt von beeblomarv:
    *struct Dyn_struct
    {
    float Dyn_float;
    int anzahl_der_Dyn_float_eingaben;
    };

    Hab zwar heute keinen richtigen Nerv, um lange Antworten zu schreiben, aber ich versuch's trotzdem mal...

    Also, mit

    Dyn_struct *zgrstruct;

    definierst du zunächst einmal einen Zeiger, der auf eine Variable deiner Struktur zeigen kann. Nun allozierst du ganz einfach Speicher für ein Strukturarray (mit n Elementen), auf dessen Anfangsadresse du dann "zgrstruct" setzt:

    if((zgrstruct=(struct Dyn_struct*)malloc(n*sizeof(struct Dyn_struct)) == NULL){
 printf("Speicherplatzmangel...\n");
 return 1;
}

    Nun musst du nur noch für jedes Element dieses Arrays ein dynamisches Array von float's erzeugen, indem du einfach in jedem Element den *Dyn_float-Komponenten entsprechenden Speicher allozierst:

    for(i=0; i<n; ++i){
 if((zgrstruct[i]->Dyn_float=(float *)malloc(zgrstruct[i]->anzahl_der_Dyn_float_eingaben*sizeof(float)) == NULL){
  printf("Speicherplatzmangel...\n");
  return 2;
 }
}

    Der Trick dabei ist, dass der Zeiger auf die float-Variable nicht den Speicher eines ganzen float-Arrays einnimmt, sondern eben nur den Speicher für einen Zeiger dieses Typs. Somit kannst du dem Strukturarray vorher Speicher allozieren und dann auf die einzelnen Elemente zugreifen und dem dyn. float-Array auch Speicher reservieren. Pass nur auf, dass du bei einem free() nicht nur free(zgrstruct) ausführst, da so der Speicher für die dynamischen float-Arrays reserviert bleibt. So ist's brav:

    // hier mal ohne Fehlerbehandlung:
for(i=0; i<n; ++i)
 free(zgrstruct[i]->Dyn_float);
// nun das Strukturarray freigeben:
free(zgrstruct);

    Hoffe mal, dass ich jetzt nicht allzuviel Mist geschrieben habe, bin heute ziemlich durch den Wind, da bleiben Logikfehler nicht aus 😃

    [ Dieser Beitrag wurde am 23.05.2003 um 18:59 Uhr von RTC editiert. ]

    0
  • ?

    @Winn

    Uupps...war wohl etwas zu langsam.

    Bye Peter.

    0
Anmelden zum Antworten