PureBoard

Verfasst: **05.05.2019 14:32**

Hallo.

Ich habe lange nichts mehr mit PB gemacht, damals viel mit Pointern usw. gearbeitet.
Heute muß ich mich neu einfuchsen.

Ich genötige eine Struktur in der ich mehrere Einträge deren Anzahl unterschiedlich nutzen will.
Die Einträge sind an sich in der "breite" fix. 64 Byte oder 128 byte.
Ich könnte jetzt ein statisches stringarray nutzen, was ich vielleicht mache und dann einfach per peek und poke auslesen usw.
Dennoch ist das unschön. und ich müßte die länge vorher ja mit einem "leestring" in der größe anpassen (und rausfinden wo und wie PB sting im arrac speichert. vermutlich als pointer und vielleicht mit größenangabe.

Daher nehme ich für sowas gerne statische Bytearrays. alo Data.b[128].
Hier kann ich direkt und leicht lesen und schreiben. die position ist ja fix im strukturspeicherbeich vorhanden.

Mit "Array" innerhalb einer Struktur habe ich noch nie gearbeitet. Wie wird ein "echtes Array" innerhalb einer Struktur speichertechnisch gespeichert?
Meine Vorstellung ist "Array Data.b(128,xxx)" und dann halt, falls die 128 byte hintereinander gespeichert werden nur noch die Einträge in der Anzahl anzupassen. xxx steht natürlich für die Anzahl die ich anpasse oder so.
Nur kommt es drauf an, wie und wo gespeichert wird.

Ansonsten würde ich es über ein statsisches STringarray machen.

Danke Toshy

Verfasst: **05.05.2019 15:27**

Code: Alles auswählen

Structure Test
  string1${100}     ; Statischer String; kann maximal 100 Zeichen aufnehmen
  
  string2${50}      ; Statischer String; kann maximal 50 Zeichen aufnehmen
  
  string3$          ; Dynamischer String; nur Pointer zum Pointer des Strings in der Struktur; Zeichenanzahl uneingeschränkt
  
  values.b[10]      ; Statisches Byte-Array
  
  Array results$(5) ; Dynamisches String-Array; nur Pointer zum String-Array in der Struktur
EndStructure

Verfasst: **05.05.2019 17:14**

Update

Code: Alles auswählen


Structure udtData
  bytearray.b[128] ; Statisches Array
  Array bytedata.b(0)  ; Array mit ein Element - In der Strukture wird der Pointer zum array gespeichert (PB interna)
  Ende.i
EndStructure

Define myData.udtData


Debug "Offset of bytearray = " + OffsetOf(udtData\bytearray)
Debug "Offset of bytedata = " + OffsetOf(udtData\bytedata)
Debug "Offset of ende = " + OffsetOf(udtData\ende)
Debug "SizeOf bytedata = " + SizeOf(udtData\bytedata)
Debug "Count of elements bytedata = " + Str(ArraySize(myData\bytedata()) + 1) ; 0..0 
Debug "Adress to bytedata = " + @myData\bytedata()

ReDim myData\bytedata(64)

Debug "Offset of bytearray = " + OffsetOf(udtData\bytearray)
Debug "Offset of bytedata = " + OffsetOf(udtData\bytedata)
Debug "Offset of ende = " + OffsetOf(udtData\ende)
Debug "SizeOf bytedata = " + SizeOf(udtData\bytedata)
Debug "Count of elements bytedata = " + Str(ArraySize(myData\bytedata()) + 1) ; 0..64 
Debug "Adress to bytedata = " + @myData\bytedata()

Verfasst: **05.05.2019 17:30**

I would suggest to do it like this:

Code: Alles auswählen

EnableExplicit

Structure STRING_STRUCT
  str.s{128}
EndStructure

Structure DUMMY_STRUCT
  Array table.STRING_STRUCT(0)
EndStructure

Global dummy.DUMMY_STRUCT

ReDim dummy\table(1)

dummy\table(0)\str = "Hello"
dummy\table(1)\str = "World!"

;Example access to all strings at once ->
ShowMemoryViewer(dummy\table(),(ArraySize(dummy\table()) + 1) * SizeOf(STRING_STRUCT))

;To read in the plain string buffer from a external source
;ReDim the table() and copy the data over using the info from above

;This method allows access to all strings seperately or at once
;allowing the data to be moved / accessed with ease

End

Verfasst: **05.05.2019 17:39**

Ein wenig mit Pointern gearbeitet...

Code: Alles auswählen


Structure udtData
  bytearray.b[128] ; Statisches Array
  Array bytedata.b(0)  ; Array mit ein Element - In der Strukture wird der Pointer zum array gespeichert (PB interna)
  Ende.i
EndStructure

Define myData.udtData


Debug "Offset of bytearray = " + OffsetOf(udtData\bytearray)
Debug "Offset of bytedata = " + OffsetOf(udtData\bytedata)
Debug "Offset of ende = " + OffsetOf(udtData\ende)
Debug "SizeOf bytedata = " + SizeOf(udtData\bytedata)
Debug "Count of elements bytedata = " + Str(ArraySize(myData\bytedata()) + 1) ; 0..0 
Debug "Adress to bytedata = " + @myData\bytedata()

ReDim myData\bytedata(127)

Debug "Offset of bytearray = " + OffsetOf(udtData\bytearray)
Debug "Offset of bytedata = " + OffsetOf(udtData\bytedata)
Debug "Offset of ende = " + OffsetOf(udtData\ende)
Debug "SizeOf bytedata = " + SizeOf(udtData\bytedata)
Debug "Count of elements bytedata = " + Str(ArraySize(myData\bytedata()) + 1) ; 0..127 
Debug "Adress to bytedata = " + @myData\bytedata()

Structure udtAnyArray
  b.b[0]
  w.w[0]
  l.l[0]
  q.q[0]
EndStructure

Procedure FillByteArray(*Data.udtAnyArray, lBound, uBound)
  Protected index
  For index = lBound To uBound
    *Data\b[index] = index & $FF
  Next
EndProcedure

FillByteArray(@myData\bytedata(), 0, ArraySize(myData\bytedata()))

For i = 0 To ArraySize(myData\bytedata())
  Debug "" + i + " = " + myData\bytedata(i)
Next

Verfasst: **05.05.2019 18:51**

Soweit erstmal Danke.

So weiß ich schon mal ein zwei Dinge mehr. Offsetof hatte ich vergessen, und mit den Pointern in dem Bezug bin ich nun auch "sicher".

Was ich noch nicht weiß bzw. verstehe sind die Diese Dinge:

1.

Code: Alles auswählen

Structure udtAnyArray
  b.b[0]
  w.w[0]
  l.l[0]
  q.q[0]
EndStructure

b.b ist an sich verständlich, an sich auch das[] dahinter. nur mit Null gefüllt [0] weiß ich nicht was es bedeutet, kann nur vermuten, daß somit zwar ein "statisches Bytearray" "angenommen" allerdings nicht erstellt / gefüllt wird. Also somit ein "Dummy" ist um zwar den Zugriff zu erhalten, allerdings nichts beim "aufruf" zu überschreiben / zu löschen (neus Bytearray über dem vorhandenen).

Ist dem so oder wie verhält es sich?

2. Was hat es mit den w, l, und q auf sich? gleichzeitig kann ich das sicher nicht verwenden. ich kann nur vermuten, entweder beginnt alles auf dem selben speicher, würde sich also überschreiben, oder es würde sich einer normalen struktur nacheinander anordnen. wie das bei einem NULLerarray funktionieren sollte verstehe ich nicht.
Vor allem wären es ja mehr als 256 byte.

schreibe ich anstatt in das Byte b in ein Word w, stürtzt das Programm ab. Ich kann nur vermuten, daß wäre nur ein Bespiel, falls ich den Speicherbereic erhöhe. Wie unter Punkt 1 bin ich mir allerdings über [0] sehr unsicher

3. Wie geht der statische Stringarray String.s[128] mit seinem Inhalt um?

Ich will einfache Bytewerte rein setzen. Das heißt also auch das NULLbyte. Da ich NICHT mit Stringcommandos arbeite (auch NICHT mit pokes) kann ich hoffen, das es klappt. normale strings brechen ja ab beim nullbyte bzw. die Verarbeitung. Ebenso ist in so einem array die Länge fix vorgegeben und bleibt wohl auch so. also könnte ich gefahrlos reinschreiben (ohne die länge wie bei einem normalen String vorher zur ein Füllen per String zu erweitern) und auch ein Nullbyte reinschreiben wie ich will(pokeb())

Das ich bei der Länge des Stringt darauf achten muß, ob es ein oder zwei Byte sind Acsii oder unicode ist klar (hangt ja davon ab, was man beim kompelieren nutzt und ich glaube gesehen zu haben, die neusten Versionen der letzten ZEit haben nutzen an sich immer intern unicode)

Anmerkung:
Im Grunde kopiere ich nur Speicherbereiche (Arbeitsspeicher bzw. aus Dateien) im Speicher um, lese sie aus usw und will nicht nur ständig mit unübersichtlichen Variablen und Positionen arbeiten. Geht, aber nervig und unschön. Vor allem, wenn man nachträglich was ändert.

In den Bereichen kommen halt Auch stings, vor, hexwert (zum anzeigen, bytetechnisch ist es ja das gleiche), allerdings auch longs, quads (größenangaben) und einzelne bytewerte. immer nach der gleichen Struktur.
Daher greife ich lieber per Struktur zu. Nur die Anzahl der Elemente variert bei einigen Teilen.
Ein einem Ersten Schritt (ach wenn unnötig) kopiere ich den normalen Speicher (allocatememory) oder auch aus der Datei,.... mal schauen, in eine Variable mit Struktur.
Es gibt sozusagen einen Kopf mit Struktur, danach aber eine unterschiedliche Anzahl an "Zeilen" die zwar die gleiche Struktur haben (nicht wie der Kopf, sondern die Zeilen sind gleich) und innerhalb dieser Zeilen steckt halt eine Datenstruktur. Daher erstmal jede "Zeile" (Datenblock) am besten in so ein string oder Bytearray.

Ich will absichtlich kein externes oder globales Array nutzen. Einfach um bei Wunsch (ich bin dabei es anzupassen) letztenlich in einem Speicherberich zu belassen und ändern zu lönnen. Und so auch einfach z.B. In einer Datei speichern zu können.

Prinziepiell eine Einfach sache, nur bin ich mir noch nicht so sicher, wie es am einfachsten ist und vor allem richtig (Ich will ja keine Speicherfehler auslösen).

Dein letzter Code, mit der zweiten STruktur ist an sich interssant und ähnlichhatte ich es auch vor. Allerdings wirkt das bei dir verünftiger und besser. Nur kapiere ich noch nicht das mit den b w l q und vor allem [0].

Danke und Gruß
Toshy

Verfasst: **05.05.2019 19:07**

Habe noch ein Bug. Es sollten alle mit den gleichen Offset beginnen

Code: Alles auswählen

Structure udtAnyArray
  StructureUnion
    b.b[0]
    w.w[0]
    l.l[0]
    q.q[0]
  EndStructureUnion
EndStructure

Normalerweise überprüft Purebasic das die Grenzen von statischen Arrays eingehalten werden.
Mit x.y[0] hat das statische Array keine Dimension und es wird die Überprüft von Purebasic abgeschaltet und der Index kann somit beliebig sein.

Verfasst: **05.05.2019 19:28**

@mk-soft

StructureUnion muss nicht sein, da alle Elemente ohnehin keine Größe haben. Finde es persönlich aber mit StructureUnion übersichtlicher.

@Toshy
Du kannst mit den Arrays ausgehend vom Zeiger die Werte auslesen. Das funktioniert auch mit negativen Werten. Ist recht praktisch, wenn du mal ein Zeichen vorwärts blicken willst ohne den Zeiger zu verändern.

Code: Alles auswählen

Structure udtAnyArray
  a.a[0]
  u.u[0]
  c.c[0]
EndStructure

Define x.s            = "PureBasic"
Define *x.udtAnyArray = @x


CompilerIf #PB_Compiler_Unicode = #False
  For i = 0 To Len (x) - 1
    Debug Chr (*x\a[i])
  Next
CompilerElse
  For i = 0 To Len (x) - 1
    Debug Chr (*x\u[i])
  Next
CompilerEndIf

Debug "------------"

For i = 0 To Len (x) - 1
  Debug Chr (*x\c[i])
Next

Verfasst: **05.05.2019 20:06**

Ah, danke. Das Beides hilft.

Ich vermute, das ich erstmal ein statisches Bytearray nutze und dann mit der "structureunion" Variante auslese und schreibe.

Ich teste mich da mal heran. AKTUELL benötige ich dann, bei der Variante noch nicht unbedingt ein dynamisches array. weil ich die Anzahl der EInträge bei dem aktuellen kleinen Projekt aus dem Header auslesen kann und nicht ändern muß. Noch nicht

Mal schauen wie viele Fehler mir dabei unter kommen. hihi.

Ich bin gerade in einem anderen Forumenabschnitt auf einen ein Jahr alten Beitrag gestoßen, der auf einen jetzt 10 Jahre altes Thema verweißt. vorzeichenlose Variablen.... das wäre echt mal schön.

Das macht es doch problematischer. ich muß mit Speicherkopieren arbeiten und schauen das Grenzwerte nicht überschnitten werden. Nun ja, ein anderes Thema. Obwohl... es bei meiner Datenstrukur die ich hier gerade bastele und diesen Beitrag betrifft schon eine Rolle spielt.

So, danke für eure schnelle Antwort. Dann kann ich heute Abend noch mal ein paar Zeilen testen.
MAn bin ich langsam geworden.....

Nun ja, und irgendwann kann ich dann, wenn es läuft sogar mein Handy endlich einrichten. hihi. Aber erstmal muß ich dafür mein PB Programm zum laufen bringen. hinbekommen. grins.

PureBoard

Struktur mit Arrays

Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays

Re: Struktur mit Arrays