PureBoard

Hallo.
Man kann auch die Größe von Elementen einer Struktur mit SizeOf() in Erfahrung bringen, nur bei LinkedList geht das nicht. Warum? Ist das ein Bug, gewollte, wie macht man es sonst?
Gruß
Toshy

SizeOf ist für komplexe Strukturen, das es mit strukturierten Variablen
funktioniert ist ein Zusatzfeature (eigentlich überflüssig), für LinkList
funktioniert es nicht (ergibt auch keinen Sinn, die größe der Strukture läßt
sich ja ermitteln)

Also ich fand es schon sehr sinnvoll, ich sollte sagen, "ich fände es sinnvoll".
Bei Proceduren oder Macros welche sehr Variabel sein sollen kann ich das gut gebrauchen. Um rauszubekommen wie groß ein Speicher ist um diese Größe z.B. an eine API-Funktion weiter zu geben, dies aber über Macros oder Proceduren läuft, welche für unterschiedliche Aufrufe zuständig sind, ist dies schon wichtig.
Vor allem wundert mich dieser unerklärliche unterschied zu strukturierten Variablen. "Eigendlich" ist beides ja das selbe, nur das die strukturierte LL ander verpackt ist. Da bei einer LL die Struktur ja auch intern auslesbar sein muß, wundert es mich, warum dies nicht auch einfach mit Sizeof() geht.
Meiner Meinung nach sollte dies schon irgendwann mal funktionieren und sei es, damit es da mal eine "klare Linie" gibt.

Falls dies aber wirklich "offiziell" nicht gehen soll, dann sollte man in der Hilfe mit aufnehmen, das man es mit allem nutzen kann, nur nicht mit den LLs.

Bei strukturierten Variablen ist die Größe gleich der Struktur, das
ermitteln der Größe dürfte also nicht so viel aufwand sein.

Bei Linkedlists kommt für jedes Element noch die interne Struktur hinzu.
Damit haben wir aber meist eher weniger zu tun, da sich PB darum
kümmert. Um die größe des Elements ohne die PB-Struktur zu
bekommen, lässt die angabe der Linkedlist weg, und gut ist. Mehr
brauchst doch garnicht, oder doch? O_O

Im zweifels falle gibs sicher irgned wo die interne Struktur zu finden.

Ach ja, in der Hilfe ist doch angegeben, wofür es geht, warum also noch
schreiben, wofür es nicht geht?

MFG PMV

eigentlich ist es unfug, dass es mit der Variablen funktioniert.

SizeOf ist eine Compilerfunktion, keine RunTime-Funktion.

also, eigentlich sollte SizeOf nur mit der Struktur selber funktionieren,
nicht mit irgendetwas, was zur laufzeit erstellt wird.

Sehe ich genauso, schließlich weiß der Programmierer ja auch, von welchem Typ seine Variablen sind, also kann er doch beim Ermitteln der Größe auch den Typ verwenden und nicht die Programmiersprache raten lassen...

wenn du das wärend der entwicklung unbedingt brauchst, weil du die typen oft änderst, dann erstell dir doch einfach die zusatzinformnation zur struktur, z.b. mit konstanten. mußt du dann zwar trotzem doppelt ändern, aber der rest des codes passt sich an.

Also habe ich es ja auch schon länger gemacht.
Aber mich wunderte halt, das es mit Variablen geht, aber nicht mit "selbigen in Arrays oder so".

Auch ist nicht zwangsweise quatsch. Natürlich weiß ein Programmierer (sollte er auf jedenfall wie seine Strukturen aussehen, aber ob ich nun Macros oder Proceduren nutze kann man diese viel variabler erstellen, wenn man die Größe auch anhand des "Variablennamens" rausbekommt.
Da es mit der "normalen Variable" geht, hoffte ich das dies immer geht.
Ich habe da eine Procedure und ein Macro die auch funktionieren sollten, wenn sich die Struktur einer Variable ändert

Also in der Art von
Ich kenne mich mit den internen Abläufen der Programmiersprache bzw. denen des Systems / Maschinencode nicht aus, aber ich vermutete halt, das intern natürlich bekannt sein muß, welche Struktur und damit Größe eine Variable hat. Wie könnte sonst später auf die Struktur zugegriffen werden. Also war für mich auch klar, das man dies wieder auslesen kann und dies in PB mit Sizeof() geschieht. Da es mit normalen strukturierten Variablen geht, warum also nicht auf mit in Arrays oder LinkedLists verpackte strukturierte Variablen.

Aber das es wohl absichtlich damit nicht geht (hat das mal jemand vom PB "offiziell" bestätigt gelesen?) ist das Thema damit wohl vorerst mal erledigt und ich kann diesen Beitrag als beendet ansehen.

> hat das mal jemand vom PB "offiziell" bestätigt gelesen?

in gewisser weise ja, denn:

SizeOf ist keine Runtime-funktion, sondern eine Compiler-funktion.
das bedeutet, das ergebnis wird schon zur kompilezeit als konstante eingesetzt.

bei variablen einfachen typs ist das logischer weise möglich,
denn der compiler kann zur compilezeit ein LONG = 4 bzw. BYTE = 1 ermitteln.

aber eben aus dem grund den du anführst
> wenn sich die Struktur einer Variable ändert
ist es nicht möglich, eine funktionierende compilezeit-funktion daraus zu erstellen.

die einzige lösung, die deinem bedürfnis gerecht würde, wäre eine,
die grundsätzlich zur runtime die größe ermittelt.

das sollte dann aber eine extra-funktion sein,
um nicht die performanz der compilezeit-benutzung aufs spiel zu setzen.

du kannst es ja mal dementsprechend ausführlich beschrieben
im englischen forum unter "feature request & wishlist" posten...

Dazu ist mein Englisch nicht ausreichend. Aber das muß auch nicht unbedingt sein. Es wäre zwar nicht schlecht, aber wenn man es weiß, dann kann man es ja wie hier schon angemerkt wurde "umgehen". Ist ja kein Beinbruch.
Und es gibt wichtigers was auf die Wunschlist gehört.

Ich weiß nun wie ich weiter machen muß und das reicht mir

Danke euch.

Gruß
Toshy