dynamisches array

die frage kommt zum 100mal
als beispiel:
structure test[x];
der wert x ist mir vorher aber nicht bekannt, erst kurz bevor die struktur aufgerufen wird.
wie kann ich so ein dynamisches feld erzeugen?

Hallo,

so gehts wohl nicht.
Schau Dir mal dynamische Speicherreservierung (malloc u.ä.) und Pointer an.
Falls dann noch Fragen sind kannst Du ja nochmal hier posten.

MfG Neo

bloodshower

Hallo!

Ich hoffe ich habe dich richtig verstanden, ein dynamisches Array könnte man so erzeugen:

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) /* Bestimmt die Anzahl der Elemente eines Arrays */ 

int i = 0; 

char *s_cont[] = {"test1", "test2", "test3"}; /* Hier kannst du soviel eintragen wie du möchtest */ 

char *dyn_array[ARRAY_SIZE(s_cont)]; 

for (i = 0; i < ARRAY_SIZE(s_cont); i++) 
{ 
   dyn_array[i] = (char *)malloc((strlen(s_cont[i])+1) * sizeof(char));  
   dyn_array[i] = s_cont[i]; 
}

Habe es in einem anderen Zusammenhang schon mal in dieses Forum gepostet.
Vielleicht bringt dich das weiter?

Gruß
Michael

hallo
also mit einem int wert ist das kein problem also

int *test = (int*) malloc(sizeof(int)*x); //x ist ein beliebiger wert, halt dynamisch
for(int i =0; i < x; i++)
{	 
   test[i] = i;
}

das funktionniert, ich moechte dasselbe aber mit einem zeiger auf eine struktur machen, also diese zeiger in einem dynamischen array ablegen, das klappt aber nicht.
vielleicht koennt ihr mir helfen?

Con*n

Hi,

probier es doch mal so:

#include <stdio.h>
#include <stdlib.h>

typedef struct {
        int x;
        float y;
        char z;
        }foo;

int main(int argc, char *argv[])
{
  foo *test = malloc(sizeof(foo)*5);

    //Beispiel für den Zugriff auf ein Element
    test[3].x=5;

free(test);
return 0;
}

das funzt ganz gut.

grüße Con@n

rüdiger

laut C99 geht das was du vorhast

#include <stddef.h>

void foo(size_t x) {
  char bar[x];
}

int main() {
  foo(100);
};

ist gültiger C99 Code. Du musst nur beachten, dass der Stack nicht sehr groß ist. Bei normalen PC Anwendungen, ist das idr. kein Problem, aber wenn du auf einem Embedded System arbeitest, solltest du lieber Heap allokierung bevorzugen (siehe malloc/calloc/free)

@kingruedi
ich moechte dass auch mit malloc und free bewerkstelligen.
bekomme aber bei der zuweisung des Strukturzeigers auf das array folgende fehlermeldung:

Compiler-Fehler C2679
Binärer Operator 'Operator' : Kein Operator definiert, der einen rechtsseitigen Operator vom Typ 'DATGroup *' akzeptiert (oder keine geeignete Konvertierung möglich)

codemaessig sieht dass so aus:

//struktur
typedef struct
{
...
...
}DatGroup;

//mache x mal speicher frei
DATGroup* datgroup_in = (DATGroup*) malloc((x)*sizeof(OVLGroup));
//zuweisung in for schleife
for( i =0; i < x ; i++ )
{	 
  datgroup_in[i] = DATGroupOpen(dat_in); 
/*DATGroupOpen(dat_in) ist eine funktion die einen zeiger auf eine struktur vom Typ DATGroup zurueckliefert*/
}

so ich weiss nicht weiter

da muss doch was gehen, wenn ich das array defineir dann funktionnierts:

//DatHandle 
datgroup_in[7];

for( i =0; i<7; i++)
{	 
  ovlgroup_in[i] = OVLGroupOpen(ovl_in);
}

da muss es doch auch dynamisch gehen?????

cpeterpan

hallo,
eine kleine frage stelle ich allen: ist das dynamisch erzeugte array global? wenn nicht, wie mach ich es global, obwohl ich die grösse des arrays erst später und nicht am anfang weiss?
danke

bei mir funktioniert dieses beispiel:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
  int NodeNr;
  int iPlugNr;
  int oPlugNr;
  //BYTE GUID[8];
  int nrOfChildern;
}savedNode;

int main()
{
   savedNode *mySavedNode;
   int size;
   int i=0;

   printf("Wie viele Werte benötigen Sie : ");
   scanf("%d",&size);

   mySavedNode=(savedNode*)malloc(size*sizeof(savedNode));

   if( NULL == mySavedNode )
      {
         printf("Fehler bei malloc....\n");
         exit(0);
      }

   while( i<size )
      {
         printf("Wert für mySavedNode[%d] eingeben : ",i);
         scanf("%d",&mySavedNode[i].NodeNr);
         i++;
      }
   printf("Hier Ihre Werte:\n");
   for(i=0; i<size; i++)
      printf("mySavedNode[%d] = %d\n",i,mySavedNode[i].NodeNr);
   free(mySavedNode);
   return 0;
}

cpeterpan

hallo,
ich glaube ich habe die antwort gefunden, man muss den zeiger savedNode *mySavedNode global definieren, der aufruf von malloc erfolg weiterhin in einer funktion

Christoph

Warum castest du das Ergebnis von malloc?
Das ist ziemlich überflüssig...

Bashar

cd9000: Wahrscheinlich, weil er es mit nem C++ Compiler compiliert. Ich hab keine Ahnung, wie die Leute immer drauf kommen, aber solche Nervereien häufen sich hier ja Wär das wirklich C, dann wär es auch C99, wegen der //-Kommentare. Also würden auch VLAs gehen.

cpeterpan

weil ich es von dieser seite übernommen habe:

http://www.pronix.de/C/standard_C/c_programmierung_17.shtml#4

und dort steht es mit casting, ich muss aber zugeben, ich habe nicht darüber gedacht, also danke für die bemerkung.

@cpeterpan
hallo, tja da bleibt noch die frage, ob du schon mal was von meiner beschriebenen fehlermeldung gehoert hast. ich komme da naemlich immer noch nicht weiter. ich kann den zeiger doch mit typedef bei meiner structure im header definieren, da ist es dann global oder?
aber was soll das aendern?
@bashar: das ist doch ein c problem?

Christoph

cpeterpan schrieb:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
 /* ... */
}savedNode;

int main()
{
   savedNode *mySavedNode;
/* ... */

Ich kenn mich mit C nicht so aus, aber muss die letzte Zeile nicht so aussehen:

int main()
{
    struct savedNode *mySavedNode;

rüdiger

nein, da es sich ja um ein typedef handelt

@adelegg

DATGroup* datgroup_in = (DATGroup*) malloc((x)*sizeof(OVLGroup));

1. hast du die Struktur DatGroup vorher genannt
2. reservierst du x mal (lass mal die Klammern um das x weg) Speicher mit der größe der OVLGroup Struktur, dabei benutzt du ja ein Array von DatGroup Strukturen!

Bashar schrieb:

Ich hab keine Ahnung, wie die Leute immer drauf kommen, aber solche Nervereien häufen sich hier ja

da kann ich dir nur leider recht geben liegt wohl daran, dass es leichter ist mittlerweile an einen C++-Compiler zu kommen als an einen C-Compiler und da ja einige Leute immer noch glauben, C++ sei zu C kompatibel, der Rest scheint von schlechten Tutorials zu kommen, wie das von pronix.de

@kingruedi
danke fuer die antworten.
zu 1.

hast du die Struktur DatGroup vorher genannt

das war ein schreibfehler, sorry von meiner seite aus,
bei meinem programm ist richtig geschrieben, also kein fehlerquelle.
leider bekomm ich immer noch dieselbe fehlermeldung

error C2679: Binaerer Operator '=' : Kein Operator definiert, der einen rechtsseitigen Operator vom Typ 'DATGroup *' akzeptiert (oder keine geeign
ete Konvertierung moeglich)

ich weiss echt nicht mehr weiter, mit einem statischen array funktionniert es einwandfrei, aber dynamisch klappt es nicht.
der aufruf sieht jetzt folgendermassen aus:

DATGroup* datgroup_in = (DATGroup*) malloc(x*sizeof(DATGroup));