struct verschachtelung dynamisch gestalten

[Eugler (Gast)]

hallo leute

als oop mensch bitte ich euch um hilfe da mir auch nach sämtlichen 
wälzen von c büchern das folgende problem noch nicht klar ist:

ich benutze structs, welche wiederum structs als parameter (seht ihr, da 
isses schon wieder) besitzen, die in ihrer grösse dynamisch sind. dieses 
spielchen kann mann ja n mal treiben. nun habe ich eine statische 
funktion die mir ein solches struct generiert. im file werden die anzahl 
der unterobjekte (ja, ich weiss) mit übergeben. dadurch hole ich mir den 
speicher am anfang.

die adresse des fertigen structs wird dann dem rückgabewert zugeführt.

hier meine fragen:

ist die alloziierung richtig? zwar besitzt jedes struct einen zeiger, 
der ist doch vom typ int? daher die berechnung?

wie kann ich das erstellte struct füllen? -> oder .? ich möchte an der 
stelle ohne eine weitere alloziierung auskommen. wie ist der 
inkrementierungsparameter? also for(i=0; i< bla; i++) structBla[i] ?. 
Kann ich dies überhaupt als array ansprechen?

wie bekomme ich den übergebenen zeiger wieder auseinander? anzahl = 
sizeof(alles)/sizeof(teil) ?

danke für eure hilfe, ich hoffe die angelegenheit ist nicht allzu banal, 
sonst schäm ich mich zu tode ;-) .

[Bernhard M. (boregard)]

Das ist ziemlich verwirrend, da z.B. structs keine Parameter kriegen 
(nur Funktionen oder Methoden) und Zeiger keine ints sind, sondern 
Zeiger....
Hänge doch mal Deinen sourcecode an, damit man nicht so rätseln muß...

[yalu (Gast)]

> als oop mensch bitte ich euch um hilfe

Was für ein OOP-Mensch bist du, bzw. welche OOP-Sprache kannst du? Deine
Fragen werden vielleicht etwas klarer, wenn du schreibst, wie du dein
Problem in Smalltalk, Java, C++ o.w.a.i. programmieren würdest. Dann
kann dir sicher jemand sagen, wie man entsprechendes in C löst.

> ich benutze structs, welche wiederum structs als parameter (seht ihr,
> da isses schon wieder) besitzen, ...

Meinst du mit "parameter" Elemente (members)? Wahrscheinlich.

> ... die in ihrer grösse dynamisch sind.

Strukturen haben normalerweise eine feste Größe. Ausnahme: Das letzte
Element einer Struktur mit mehreren Elementen darf ein Array mit
unspezifizierter Größe sein (bspw. int array[];). Solche Strukturen
werden meist dynamisach mit malloc alloziert, da man nur damit die
Möglichkeit hat, dem Array eine von Null verschiedene Größe zu geben.

Jedes Element einer Struktur kann ein Zeiger sein. Der Zeiger hat zwar
konstante Größe, aber das, worauf er zeigt, kann das erste Element eines
Arrays oder einer Struktur mit dynamischer Größe sein.

Jedes Array kann seinerseits einfache (int, double, ...) oder
zusammengesetzte Datentypen (Strukturen, Unions oder Arrays) als
Elemente enthalten.

> ist die alloziierung richtig?

Welche meinst du?

> zwar besitzt jedes struct einen zeiger, der ist doch vom typ int?
> daher die berechnung?

Häh? Welcher Zeiger, welche Berechnung? Zeiger sind übrigens vom Typ
<typ> *, wobei <typ> ein beliebiger Datentyp wie int, double, struct s
usw. sein kann.

> wie kann ich das erstellte struct füllen? -> oder .?

Wenn man auf die Strukturvariable v direkt zurgreifen kann, nimmt man
den .-Operator, also bspw v.element. Wenn man nur einen Zeiger vptr auf
die Struktur hat, schreibt man eben (*vptr).element oder einfacher
vptr->element. Natürlich können diese Operatoren bei Unterstrukturen
auch verkettet werden, bspw. v.unterstruktur.element oder
vptr->unterstruktur.element oder v.unterstrukturzeiger->element.

> wie ist der inkrementierungsparameter?

Was möchtest du inkrementieren? In C können nur numerische Variablen und
Zeigervariablen inkrementiert werden.

> wie bekomme ich den übergebenen zeiger wieder auseinander? anzahl =
> sizeof(alles)/sizeof(teil) ?

Aus einem Zeiger lässt dich die Größe des Objekts, auf das er zeigt,
mittels sizeof nur dann bestimmen, wenn das Objekt eine feste (nicht
dynamische) Größe hat. Bei Objekten dynamischer Größe muss die Größe
anderweitig (bspw. als zusätzliches Strukturelement) bereitgestellt
werden.

[daniel (Gast)]

die declarationen der structs sind in c nicht mehr abzuändern.
sie sind statisch. objekte hingegen kann man schachteln, auch
dynamisch zur laufzeit. dazu werden gerne mal void ** ppv benutzt.
eine indirektion wird als array misbraucht, an die andere werden
objekte angehängt^^

in python und ruby ist alles dynamisch, auch die "struct" deklaration
kann während des programablaufs geändert werden. es können neue
klassen erstellt werden etc.

mit oop hat hat es meiner meinung nach nix zu tun.

[Eugler (Gast)]

hallo

erstmal danke für die antworten. natürlich hätte ich gleich das file 
anhängen sollen, beziehe mich ja auch im post darauf.

[P. S. (Gast)]

out = &myTopTop;

Ist schonmal falsch, da sollte der Compiler mindestens warnen. Du willst

*out = myTopTop;

Die Verknuepfung der Objekte fehlt ja leider. Mache die einfach so, wie 
du sie in jeder anderen Sprache auch machen wuerdest.