Am 05.07.2021 um 23:42 schrieb Rainer Rosenthal:
> Freue mich auf weitere Antworten.
kenne das nur aus der Programmierungs-Ecke:
Klasse B erbt von A.
Also, Du hast 2 Klassen
Klasse B { verbunden (ref_prev) mit C }
Klasse C { verbunden (ref_prev) mit B }
wie man schon sehen kann, entsteht eine Symmetrie, oder
Kreisel-Verbundenheit genannt.
Dem kann man entgehen, wenn man eine 2. Eigenschaft, vom
selben Typus der Klasse hinzufügt - oben in Klammern, das
ref_prev.
Dann würden die beiden Klassen aus, eine gemeinsame Oberklasse
bestehen, die gleiche Eigenschaften haben, aber jeweils mit
einer anderen Referenz ausgestattet sind.
Diese Referenzen unterscheiden sich dann nochmal im Speicher -
aber das erstmal nur so als flappsige Nebenbemerkung.
Die Struktur:
// dies ist die Oberklasse:
Klasse Gesamt {
Gesamt ref_prev
Gesamt ref_next
}
Jetzt geht man her, und initialisiert "Gesamt" mit einer globalen
Variable - ich nenne diese mal "Root", und setzt "ref_prev" auf
Null - logisch, hat ja am Anfang keinen Vorfahren.
Gleiches macht man "ref_next".
Jetzt erweitert man die globale Variable "Root" um 1 Element mit der
"Gesamt" Klasse (Gesamt ist hier nur als Vorlage zu betrachten, da
sowohl:
"Root (0)" := erstes Element, und das erstellte
"Root (1)" := zweite Element von der gleichen Klasse "Gesamt" erben.
Root (1) wird nach dem initialisieren mit einen Zeiger auf "ref_prev"
(also dem Vorgänger) versehen, während der Nachfolger "ref_next"
wieder mit Null belegt wird - da ja kein Nachfolger in diesem Moment
existiert.
Schaubild von Root (0):
+-----------------+
| Root (0) / self | // Selbstreferenz
+-----------------+
| NULL | // Nichts zugeordnet, um <=> zu vermeiden
+-----------------+
Schaubild von Root (1):
+-------------+
| Root (1) | // Selbstreferenz (Nachfolger)
+-------------+
| Root (0) | // Vorgänger
+-------------+
Beide zusammen:
+-----------------+
| Root (0) / self | <------------+
+-----------------+ |
| NULL | |
+-----------------+ |
|
+-------------+ |
| Root (1) | <----( )---+
+-------------+ | |
| Root (0) | >-----+ |
+-------------+ |
... |
+-------------+ |
| Root (n+1) | |
+-------------+ |
| Root (n) | >----------+
+-------------+
Durch geschickte Programmierung kann man den Level,
also die Tiefe (die Spanne der Entfernung) ablesen.
Es ist weiter möglich, wenn beide Elemente die gleichen
Level haben, also durch keine andere Eigenschaften wie
Baum, Schild, Auto, etc.. behindert werden, zu Entscheiden:
"Okay, A und B stehen auf den Dächern der Towers, und können
sich dadurch sehen.".
Das macht jede einfach gehaltene GrafikEngine mittels View.
Man kann das auch einen Schüler programmieren lassen, der
mittels Turbo Pascal unter DOS mit den BGI Treiber grafische
Objekte zeichnen kann - im zweidimensionalen Raum - mit ein
wenig Pythagoras lassen sich dann auch einfach 3D Bewegungen
simulieren.
Hat vielleicht den Nachteil, das die Darstellung der Linien
und/oder Flächen sich gegenseitig "bemalen", aber ich Denke,
für eine kleine Herausforderung wäre das nicht von schlechter
Form.
Also dann, Jens
P.S.: Achja, hab ich ja noch vergessen zu schreiben:
Wer nach dem Begriff sucht, dem empfehle ich "linked-lists"
mal näher unter die Lupe zu nehmen.