Array Probleme...

[PureLust]

@Fluid Byte
Du scheinst nicht bedacht zu haben, dass eine Structur zur Compilezeit festliegen muss und nicht dynamisch wärend der Laufzeit "angelegt" wird.

@ReneMiner

Die Geschichte mit einer dynamischen Anzahl von Titeln für jeder Schallplatte kannst Du aber auch noch mit reinen PB-Bordmitteln lösen:

Die Schallplatten selber kannst Du wie von Dir gewünscht in einem normalen Arrey speichern und so über den Index darauf zugreiffen.
Um zu jeder Platte eine dynamische Anzahl an Titeln zu realisieren, werden einfach alle Titel in einer großen LinkedList gespeichert.

Bei dieser Liste ist es wichtig, dass sich alle zu einer Schallplatte gehörenden Titel hintereinander in der LinkedList befinden.
Dies ist aber recht einfach zu realisieren.

Um nun jederzeit auf die zu der jeweiligen Schallplatte gehörenden Titel zugreifen zu können brauchst Du in der Schallplatten-Struktur nur die Adresse des ersten und letzten zu dieser Platte gehörenden Titel-Elements zu speichern.
Hierdurch kannst Du die Anzahl der Titel die zu einer Platte gehören vollkommen dynamisch verwalten.

Wie Du das Ganze nun umsetzen kannst zeig' ich Dir mal an einem Beispiel:

Code: Alles auswählen

Structure LiedStruct 
    Titel.s 
    Interpret.s 
    Laenge.l 
EndStructure 

Structure eineSchallplatte 
  AlbumName.s      
  nTitel.l 					; Anzahl der Titel
  ErstesLLElement.l		; Zeiger auf erster  Lied welches zu dieser Schallplatte gehört
  LetztesLLElement.l		; Zeiger auf letztes Lied welches zu dieser Schallplatte gehört
EndStructure 

Global Dim Platte.eineSchallplatte(9)
Global NewList EinLied.LiedStruct()

; ############################################################################################ 
; # Mit dieser Prozedur kannst Du einer Schallplatte jederzeit einen neuen Titel hinzufügen. # 
; ############################################################################################ 

Procedure AddSong(Schallplatte, Titel.s, Interpret.s, Laenge.l)
	If Platte(Schallplatte)\LetztesLLElement
		ChangeCurrentElement(EinLied(), Platte(Schallplatte)\LetztesLLElement)
	EndIf
	AddElement(EinLied())
	EinLied()\Titel		= Titel
	EinLied()\Interpret	= Interpret
	EinLied()\Laenge		= Laenge
	Platte(Schallplatte)\LetztesLLElement = @EinLied()
	If Not Platte(Schallplatte)\ErstesLLElement : Platte(Schallplatte)\ErstesLLElement = @EinLied() : EndIf
	Platte(Schallplatte)\nTitel + 1
EndProcedure

For n = 1 To 100
	AddSong(Random(9), "Titel_"+Str(10000+Random(9999)),  "Interpret_"+Str(10000+Random(9999)), Random(3*60) + 120)
Next n

For n = 0 To 9
	Debug "Die Schallplatte Nr. "+Str(n+1)+"  hat "+Str(Platte(n)\nTitel)+" Titel."
	If Platte(n)\ErstesLLElement
		ChangeCurrentElement(EinLied(), Platte(n)\ErstesLLElement)
		Repeat
			Debug "  - "+EinLied()\Titel + "  "+EinLied()\Interpret + "   Länge: "+FormatDate("%ii:%ss",EinLied()\Laenge)
			If @EinLied() = 	Platte(n)\LetztesLLElement : Break : EndIf
		Until Not NextElement(EinLied())
	EndIf
Next n

Gruß, PL.

[mk-soft]

Würde eher zwei LinkedList erstellen und wie in einer Datenbank mit einer ID arbeiten und mit einer 1 zu unendlich verknüpfen.
Beide LinkedList nachher in zwei Tabellen speichern.

habe jetzt erst mal keine Zeit.
Mal ein ansatz dazu.

Code: Alles auswählen

Structure udtAlbum
  ID.l
  Name.s
  Titel.s
EndStructure

Structure udtTitel
  ID.l
  Titel.s
  Interpred.s
  laenge.l
EndStructure


Global NewList Album.udtAlbum()
Global NewList Titel.udtTitel()


; ID für Album vergeben - muss eindeutig sein
ID = Date()

AddElement(Album())
With Album()
  \ID = ID
  \Name = "Steve Winwood"
  \Titel = "XYZ"
EndWith
; Titel zu ID des Albums erstellen
For i = 1 To 10
  AddElement(Titel())
  With Titel()
    \ID = ID ; Immer gleiche ID wie Album
    \Titel = "Titel " + Str(i)
  EndWith
Next i

FF

[PureLust]

Würde eher zwei LinkedList erstellen ...

; eine Liste wäre aber ungeeignet da ich die "Platten" über ihre
; Index-Nummern aufrufen will und muss.

[mk-soft]

Index == ID

Wenn man noch weiter denk kann auch noch die Interpreten in einer dritten linkedlist ablegen und nur noch in der Titelliste mit InterpretID verbinden.

Ganz normale rev. Datenbank.

[PureLust]

Ich interpretiere seine Aussage so, dass er einfach Platte 5, 7, 23, 5972 etc. direkt per Array-Index ansprechen können möchte und eben nicht:

Code: Alles auswählen

ForEach Album()
	If Album()\ID = Index
		...
	EndIf
Next

Weiterhin ist natürlich auch der Zugriff auf die zum Album gehörenden Titel durch die Verwendung der Zeigern erheblich schneller als wenn er auch dafür wiederum zig-tausende von Titeln durchlaufen muss:

Code: Alles auswählen

ForEach Titel()
	If Titel()\ID = Index
		...
	EndIf
Next

[Kaeru Gaman]

ich hör immer nur schneller, schneller...
(sagt ihr das woanders auch? ..und was sagt eure freundin dazu)

wenn ich per hand einen titel eingebe, den ich suchen will, oder eine index nummer,
dann ist die suche selbst beim komplett durchlaufen der liste schneller beendet,
als ich den titel eingetippt habe.
...klingt komisch, ist aber so.

und selbst wenn ich Ol'Quincy Jones wäre, und meine plattensammlung
nen extra stützbalken im boden bräuchte um nicht durchzubrechen,
wäre die komplettsuche immer noch schnell.
und wenn es mir wirklich nicht schnell genug geht,würde immer noch die zwei listen-lösung helfen.

leute... "schnell"... seid froh, dass ihr niemals in einem handschriftlichen drei lagerräume
großen archiv etwas suchen mußtet, bevor es billige computer gab.


...zwei listen..

in der einen liste stehen die indices und ein connector, die ist nach indizes sortiert.
per binärem suchen brauche ich maximal 8 zugriffe für 2^8 einträge.

in der zweiten liste stehen die titel und ein connector, die ist nach titel sortiert.
auch hier suche ich genauso schnell.

wenn ich nen neuen titel eingebe, dann werden beide listen neu sortiert und die connectoren (pointer auf elemente der anderen liste) aktualisiert.
also, allein der speichervorgang von neuen titeln dauert etwas länger.

und wie gesagt, kein arsch hat so viele platten sorry.


PS:
und für sowas gibt es datenbanksysteme, die machen sowas automatisch.
man braucht nicht immer das rad neu erfinden.

dafür arbeiten die leute schon seit jahrzehnten an effektiven datenbanksystemen.
früher war sowas nämlich wirklich nötig, weil die großrechner langsamere CPUs
hatten als jeder rechner den ihr letztes jahr aufn müll geschmissen habt.
und da war auch der zugriff beschränkt, da konnte man nicht einfach aufn knopp drücken und nen probelauf machen.
mein erstes programm auf nem rechner der mehr als 64KB Hauptspeicher hatte,
das war in Cobol, und ich durfte drei stunden auf den ausdruck warten,
ob mein billiges kleines proggi die liste auch richtig formatiert hat.

[mk-soft]

ich hör immer nur schneller, schneller...
(sagt ihr das woanders auch? ..und was sagt eure freundin dazu)

Danke!

[ReneMiner]

Tja- das Problem ist nur das ich doch die Schallplatten und Lieder nur genommen habe um mein Problem rüberzubringen. In Wirklichkeit hab ich es natürlich mit Gruppen von Dreiecken und Vertizen zu tun deren Anzahl sich auch dauernd ändert und die ich ständig umsortieren, umindizieren, umrechnen und was weiss ich noch alles muss. So kommts das jede Gruppe eine unterschiedliche Menge an Mitgliedern haben kann und die hätte ich natürlich gerne übersichtlich nummeriert z.B. so hier:

Code: Alles auswählen

; structures sind ja ersichtlich, also:

;... ah - ein neues Mitglied...

Redim Gruppe(GruppenIndex)\Mitglied(NeueMitgliederAnzahl)

Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Farbe=Farbe
Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Grösse=Grösse

wäre ja ausreichend...
von solchen Konstrukten wie

Code: Alles auswählen

Bild(BildIndex)\Gruppe(GruppenIndex)\Mitglied(MitgliedIndex)\Eigenschaften\Farbe=Farbe

möchte ich da erstmal absehen und meine Erwartungen nicht zu hoch schrauben.

Ebenso gut wäre es wenn LinkedLists als structure-Elemente verwendbar wären - oder umgedreht: wenn man ein Array von LinkedLists erstellen könnte

Code: Alles auswählen

structure paarEigenschaften
  Farbe.l
  Grösse.l
endstructure

structure einMitglied 
    Eigenschaft.paarEigenschaften
    blub.b
    bla.l
endstructure

structure eineGruppe
    Mitglied.LinkedList(einMitglied)
    toll.s
    prima.b
endstructure


; bzw. schön wäre auch das

CreateListArray(Listenname.Typ, 10)
; erstellt ein Array von 10 LinkedLists 
...
ReCreateListArray(Listenname, 5)
; hier hätte ich nur noch 5 Listen
...
ReCreateListArray(Listenname, 15)
; und jetzt 15...

ResetList(Listenname[ListIndex]())
While NextElement(Listenname[ListIndex]())

Da wären eckige Klammern wohl angebracht und verständlich...

[Kaeru Gaman]

das Problem ist nur das ich doch die Schallplatten und Lieder nur genommen habe um mein Problem rüberzubringen. In Wirklichkeit hab ich es natürlich mit Gruppen von Dreiecken und Vertizen zu tun deren Anzahl sich auch dauernd ändert und die ich ständig umsortieren, umindizieren, umrechnen und was weiss ich noch alles muss.

dann sag das doch bitte gleich...
du bist hier in einem programmiererforum, da solltest du sagen, worum es dir geht,
(du musst hier keinen azubis im ersten halbjahr berufsschulinformatik ein EDV problem bildhaft schildern)
weil unterschiedliche problemstellungen nunmal unterschiedliche ansätze brauchen,
je nachdem um was für eine verwaltung es sich nun handelt.

wenn du jetzt noch mal ausführlicher erklärst, was deine spezifische problemstellung ist,
könnte es nämlich durchaus sein, dass jemand daherkommt:
"ach, das willst du machen? das kann man ein bißchen anders besser lösen, guck mal hier, so hab ich das vor nem halben jahr gelöst"

...das kann er aber nur, wenn er weiß, dass du nicht deine plattensammlung sortieren willst.

[ts-soft]

XML erfüllt alle Bedingungen, warum hörste nicht auf meinen Tip?