struct deklarieren, an funktion übergeben und dort mit new speicher reservieren ?

RML

hi,
ich hab ein paar verständnissprobleme, was zeiger betrifft (nicht neues denke ich )

wenn ich ein struct erzeuge wie

typedef struct m_item
{
char Name[40];
int Parent;
int SMlet;
int Subcnt;
struct *m_item;
RECT Rect;
} MITEM;

MITEM *MainItems;

dann in der Main eine Funktion aufrufe, die mir mit new ein Array in der entsprechenden grösse erzeugt.

wie müssen die Zeiger übergeben werden ????

mit einer konstuktion wie:

void Create_Item_List(MITEM &Iteml,int i)
{
MITEM *Iteml = new MITEM[i];
}

die funktion soll von der main aufgerufen werden.

z.B. Create_Item_List(*MainItems,10);

ziel soll sein, den o.g. Zeiger (*MainItems) an die funktion zu übergeben und dort die Grösse per new festzulegen.

was muss an die funktion übergeben werden ? soweit ich weiss, entspricht "*" dem wert, der an der Adresse gespeichert ist und '&' gibt die speicheradresse zurück.

ich müsste demnach doch '&MainItems' an die Funktion 'Create_Item_List(MITEM &Iteml,int i)' übergeben, was nicht geht. was muss denn nun wo wie übergeben werden, damit ich "Iteml" ändern kann ? leider gehen sehr viele tutorials auf malloc ein. malloc soll man aber nicht mehr verwenden, wie ich gelesen habe.

hat jemand eine idee ? ich sitze nun schon seit tagen an dem problem und finde für dieses anfängerproblem keine lösung.

über etwas einsteigerhilfe würde ich mich freuen :p

gruß
aus berlin

Blue-Tiger

ok.. ich hoff ich hab dich nicht missverstanden:

zum einen: der Funktionskopf/der Aufruf muss/muessen so aussehen:

// Funktionskopf:
void Create_Item_List(MITEM* Iteml,int i)

// Aufruf:

MITEM my_mitem
Create_Item_List(&mymitem, 10)

d.h. kein "MITEM&", sondern ein "MITEM*".... was der Unterschied ist? ein Mitem& ist eine Referenz auf einen MITEM. Wenn dir das im Moment nix sagt, macht das nix, Referenzen sind eine Art "vereinfachter Pointer", du wirst sicher noch lernen, was Referenzen sind, wenn du dich weiter mit C++ beschaeftigst...

ein MITEM* hingegen ist ein Pointer auf einen MITEM..... ein Pointer (engl. "Zeiger") ist ein Zeiger auf eine Speicheradresse. Am Anfang wird dich das vielleicht verwirren, wenn du noch nie was ueber Pointer gehoert hast, aber no Panic, wirst du auch noch lernen

Egal, kurz gesagt:

&MITEM gibt dir die Adresse des MITEM. Solche Adressen speichert man in "Pointern"... also in MITEM*

kleines Codebeispiel:

MITEM my_mitem; // ein MITEM erstellen

&my_mitem;      // liefert einfach nur die Adresse von my_item im Speicher

MITEM* pointer_to_mitem  // in so einer Variable kann man eine MITEM-Speicheradresse speichern

// kombinieren wir das:

pointer_to_mitem = &my_mitem; /// pointer_to_mitem enthaelt nun die Speicheradresse von my_mitem ("er zeigt auf my_mitem")

Ich hoffe das war halbwegs verstaendlich und hilft dir weiter

triendl.kj

ich denke, du möchtest eine funktion, die dir die speicherreservierung abnimmt, aus welchen gründen auch immer.
wenn ja, dann geht das so:

struct MITEM {};

void Create_Item_List(MITEM** item, int i)
{
 *item = new MITEM[i];
}

void Create_Item_List(MITEM*& item, int i)
{
 item = new MITEM[i];
}

int main()
{
 MITEM* mitem(0);
 MITEM* mitem1(0);
 Create_Item_List(&mitem, 5);
 Create_Item_List(mitem1, 4);
 delete[] mitem;
 delete[] mitem1;
}

die erste Create_Item_List() übernimmt einen zeiger auf einen zeiger, die zweite eine referenz auf einen zeiger - ein alias auf das ursprüngliche objekt (mitem1).

übrigens kannst du einer funktion nie einen typ übergeben, nur ein echtes objekt. der typ ist Create_Item_List() ohnehin bekannt durch die globale deklaration von MITEM.

RML

ja, sowas in der art wollte ich. ich habe das problem mit einer verketteten Liste gelöst, da ich auf dem weg nicht weiter kam. Danke aber für die Antworten

Walli

Es gibt bereits Containerklassen im Standard die das können (z.B. deque). Ich hoffe du hast dir jetzt keine eigene Klasse gebaut.