[C] 2dimensionale array of array van pointers?

[Marc]

Hey,

sorry voor de gare titel, maar ik ben nooit goed in dat soort dingen.
ik zit met het volgende probleem:
Ik heb een structure gedeclareert waarin ik vrij veel data wil stoppen, zoiets bijvoorbeeld:

code:

struct mem_t
{
   const char object[20][40];
   const char tool[25][50];
};

hier komt mijn vraag eigenlijk al, is dit een slimme manier om data te reserveren? of kan ik beter met een array van pointers werken en dan met malloc(); data reserveren? zoiets dus:

code:

struct mem_t
{
   const char *object[40];
   const char *tool[50];
};

ik weet niet, ik vind de eerst code er nogal lelijk uitzien eigenlijk.

ik moet er wel even bijzeggen dat ik later ook dynamisch objects en tools wil kunnen toevoegen. dat de eerste code werkt weet ik dus wel, ik vroeg me alleen af of er geen nettere manier is

[Verwijderd]

En dan kan je ook nog 20 malloc()s doen of 1 malloc() doen en die verdelen in 20 stukken.

Volgens mij maakt het niet zoveel uit en is het een kwestie van smaak.

[rollebol]

Ik zou eens een datastructuren-boek ter hand nemen en kijken wat een linked list is. Je kan dan dynamisch je 'array' uitbreiden. Afhankelijk van hoeveel flexibiliteit je nodig hebt is dat handiger dan dit. Je kan bijvoorbeeld dan ook ergens halverwege de array iets 'invoegen'.

[Robtimus]

Marc schreef op 19 juli 2004 @ 18:53:

code:

struct mem_t
{
   const char object[20][40];
   const char tool[25][50];
};

code:

struct mem_t
{
   const char *object[40];
   const char *tool[50];
};

1 ding: in het eerste heb je in je 2D array 20 arrays van elk 40 characters. In de tweede 40 "arrays" van nog onbekende lengte. Verkeerd om gedaan dus.

[Marc]

IceManX schreef op 19 juli 2004 @ 19:26:
[...]
1 ding: in het eerste heb je in je 2D array 20 arrays van elk 40 characters. In de tweede 40 "arrays" van nog onbekende lengte. Verkeerd om gedaan dus.

my bad je hebt helemaal gelijk, maar dit is gelukkig niet mijn echte code, ik heb dit even gemaakt als voorbeeld.
maar het idee begrijp je wel.

even over die linked list, als ik het idee goed begrijp, maak je dus in de structure een pointer die naar de volgende structure wijst? dan krijg je dus zoiets:

code:

struct link_list_t
{
  char object[20][40];
  struct link_list_t *next_ptr;
};

maar wat schiet ik hier nou precies mee op?

[markvt]

Een array zo groot als de maximale geheugenruimte.

[Marc]

ah ik denk dat ik hem snap! ik moet het dan zeker zo doen:

code:

struct link_list_t
{
  char object[40];
  struct link_list_t *next_ptr;
};

nu kan ik een variable aantal structures maken dmv die linked list.

[MSalters]

Pcies, je doet een malloc( sizeof(link_list_t) ) voor elk element. Dat kun je dus blijven doen tot je geheugen vol is.

[farlane]

Je zou de grootte van je object ook nog variabel kunnen maken

[Marc]

dat zat ik dus ook te denken ja, dan krijg je zoiets:

C:

typedef struct object_t OBJ;
typedef struct tool_t TOO;

struct object_t {
   char object[40];
   OBJ *next_ptr;
};

struct tool_t {
   char tool[40];
   TOO *next_ptr;
}

struct mem_t
{
   OBJ object;
   TOO tool;
};

neat!
nu niet zo bijster nuttig, maar als je onafhankelijke elementen in de structure mem_t wilt zetten is het wel handig.

[ Voor 18% gewijzigd door Marc op 20-07-2004 23:40 . Reden: code=c :) ]

[.oisyn]

Overigens

Marc schreef op 19 juli 2004 @ 18:53:
Hey,

sorry voor de gare titel, maar ik ben nooit goed in dat soort dingen.
ik zit met het volgende probleem:
Ik heb een structure gedeclareert waarin ik vrij veel data wil stoppen, zoiets bijvoorbeeld:

code:

struct mem_t
{
   const char object[20][40];
   const char tool[25][50];
};

hier komt mijn vraag eigenlijk al, is dit een slimme manier om data te reserveren? of kan ik beter met een array van pointers werken en dan met malloc(); data reserveren? zoiets dus:

code:

struct mem_t
{
   const char *object[40];
   const char *tool[50];
};

Zoals gezegd gaat dat niet goed, omdat je daar een array van 40 pointers naar char declareert, terwijl jij juist wil dat je een 2d array waarbij de achterste dimensie steeds 40 is. Oftewel, een array met variabele lengte van arrays van 40 chars. En een array met variabele lengte doe je natuurlijk met een pointer. De truc is echter alleen even de juiste schrijfwijze te weten:

C:

struct mem_t
{
    const char (*object)[40];
    const char (*tool)[50];
};

Het alloceren van een object in een mem_t kan dan als volgt:

C:

int main ()
{
    mem_t mem;
    
    mem.object = malloc (aantal_arrays * sizeof (char[40]));
}

tool gaat natuurlijk op eenzelfde manier . Het benaderen ervan is dan gewoon als een 2d array: mem.object[23][34] = '3' oid.