doppeltes foreach der selben liste?

[Kaisky007]

hi, bin noch anfänger mit der programmierung, habe es früher schonmal versucht, musste aber aufgeben :(
ich wollte ein "sternsystem" programmieren, das jeder stern / planet von anderen angezogen wird, und sie anzieht.
lief ganz gut, bis ich nicht wusste wie ich machen kann das alle elemente in einer liste sich gegenseitig abfragen. wenn ich 2 unterschiedliche listen habe die sich gegenseitig abragen wollen, mache ich einfach foreach liste1 und dann foreach liste2
aber ich will ja foreach liste1, foreach liste1, aber er kann ja dann nicht wissen welches der beiden ich meine wenn ich ein element aufrufe.
gibt es dafür einen bestimmten befehl oder so? oder ein trick?
das was ich bisher habe habe ich jetzt nicht vorliegen, bin an einen anderen computer, und an meinen ist grade das i-net kaputt :(

[gekkonier]

Soweit ich das verstehe willst du also jedes Element einer Liste mit jedem anderen "durchrechnen" und zwar genau einmal pro möglicher Kombination.

Falls das stimmt, kuck dir mal das da an (Innerhalb der beiden Schleifen mit idx1 und idx2 als Index für die Liste arbeiten. Die Debugausgabe sollte verdeutlichen was gemeint ist):

Code: Alles auswählen

; Kombinatorik - jede mögliche Paarkonstellation einer Liste

NewList MyList.s()

AddElement(MyList())
MyList() = "a"
AddElement(MyList())
MyList() = "b"
AddElement(MyList())
MyList() = "c"
AddElement(MyList())
MyList() = "d"

For idx1 = 0 To ListSize(MyList()) - 2
  For idx2 = idx1 + 1 To ListSize(MyList()) - 1
    SelectElement(MyList(), idx1)
    ding1.s = MyList()
    SelectElement(MyList(), idx2)
    ding2.s = MyList()
    Debug ding1 + " " + ding2 ; hier spielt die Musik!
  Next
Next

edit: unnötige Structure rausgenommen... mei bin ich fertisch...

[STARGÅTE]

falls die Listen größer werden ist ein SelectElement unglaublich langsam,

bessere variante ist:

Code: Alles auswählen

Structure Stern
 Masse.f
 x.f
 y.f
EndStructure

NewList Stern.Stern()
For n = 1 To 5
 AddElement(Stern())
 Stern()\Masse = n
Next

; Jedes mit jedem (ein mal)
ForEach Stern()
 *Stern1.Stern = Stern()
 While NextElement(Stern())
  *Stern2.Stern = Stern()
  ; Ausgabe der beiden Sterne:
  Debug "Kombination: "+Str(*Stern1\Masse)+" mit "+Str(*Stern2\Masse)
 Wend
 ChangeCurrentElement(Stern(), *Stern1)
Next

Das erlaubt auch schnelleren Zugriff auf die ElementStructureVariablen

[Kaisky007]

das heißt, ich kann dann ganznormal alles hinschreiben wo du debug hast, nur immer statt Stern()\Masse *Stern1\Masse ???
hoffe ich verstehe nix falsch, komplizierte sache, zu programmieren, besonders wenn man neu ist

[Fluid Byte]

das heißt, ich kann dann ganznormal alles hinschreiben wo du debug hast, nur immer statt Stern()\Masse *Stern1\Masse ???

Ob du Stern()\Masse schreibst oder es mit Pointern umsetzt macht keinen Unterschied, ist reine Geschmackssache.

[Kaisky007]

wuaa *verwirrung*
sind pointer die *?
ähm.. ich muss also wo ich Global New List Stern.Stern() (oder so) stehen habe, muss Global New List Stern1.Stern() und nächste zeile Global New List Stern2.Stern() ? und dann eben entweder Stern1()\blablabla oder Stern2 blablabla machen?

[STARGÅTE]

also wenn du EINE EINZIGE Liste mit sich selber vergleichen willst, dann brauchst du POINTER also die *
die die Position des Elements speichert.

Wenn du nur Sterne hast dann reicht halt eine Liste, falls du sie in Proceduren verwenden willst, wäre Global nicht schlecht.

Aber eine Liste reicht halt um die Sterne sich anziehen zu lassen ...

[Kaisky007]

jap
ich glaube ich habe es endlich verstanden xD
im foreach stern muss ich *Stern1.Stern und *Stern2.Stern machen, und dann wenn ich es aufrufen will *Stern1\blablabla und *Stern2\blabla
danke, ich gehe wieder an meinen computer und teste es

[Fluid Byte]

also wenn du EINE EINZIGE Liste mit sich selber vergleichen willst, dann brauchst du POINTER also die *
die die Position des Elements speichert.

Nö.

Code: Alles auswählen

Structure Stern
	Masse.f
	x.f
	y.f
EndStructure

NewList Stern.Stern()

For n = 1 To 5
	AddElement(Stern())
	Stern()\Masse = n
Next

; Jedes mit jedem (ein mal)
ForEach Stern()
	altStern = Stern()
	altMasse = Stern()\Masse
	
	While NextElement(Stern())
		; Ausgabe der beiden Sterne:
		Debug "Kombination: "+ Str(altMasse) + " mit " + Str(Stern()\Masse)
	Wend
	
	ChangeCurrentElement(Stern(),altStern)
Next 

[STARGÅTE]

jo klar, das war auch meine "alte" Variante damals,

aber inzwischen habe die die Pointer schätzen gelernt...
Es ist einfach kürzer ...