Baumstruktur mit fehlern :(

[glkgereon]

hi

ich will eine Baumstruktur aufbauen.
jeder knoten soll 0-4 kinder haben.
das ganze soll nachher auf eine paintbox gemalt werden.
(konkret geht es um die darstellung von Alkanen (zb Methan, Butan, Propan))

dazu habe ich mir folgenden typ gemacht:

Delphi-Quellcode:

type
  TNode = record
    Parent: Pointer;
    ChildCount: Byte;
    Childs: array [1..4] of Pointer;
    x,y: Integer;
  end;

und das ganze in eine TList geschmissen.

Delphi-Quellcode:

procedure AddNode(Parent: Pointer; PX, PY, Count: Integer);
var Temp: TNode;
    i:Integer;
begin
  for i:=1 to Count do
    begin
    Temp.ChildCount:=StrToInt(InPutBox('Childs','ChildCount','1'));
    Temp.Parent:=Parent;
    {1: 0, 1
     2: 1, 0
     3: 0,-1
     4:-1, 0}
    Temp.x:=PX - (i-2);
    Temp.y:=PY - (i-3);
    Form1.Nodes.Add(@Temp);
    AddNode(@Temp.Childs[i], Temp.x, Temp.y, Temp.ChildCount);
    end;
end;

procedure DrawAgain;
//malen
var i: Integer;
begin
  with Form1 do
    for i:=0 to Nodes.Count-1 do
      with TNode(Nodes.Items[i]^) do
        PaintBox1.Canvas.Arc(x*10,y*10,x*10+8,y*10,x*10,y*10+8,x*10+8,y*10+8);
end;

procedure TForm1.Button1Click(Sender: TObject);
//Neu eingeben
var Temp: TNode;
    Parent: Pointer;
begin
  AddNode(nil,0,0,1);
  DrawAgain;
end;

procedure TForm1.Button2Click(Sender: TObject);
//Debug
var i:Integer;
begin
  for I:=0 to Nodes.Count-1 do
    with TNode(Nodes.Items[i]^) do
      ListBox1.Items.Add(IntToStr(x)+'   '+IntToStr(y));
end;

nur leider kommen total bekloppte x/y-werte heraus....
zb:
//Button1Click
eingabe: 2,0,0
//Button2Click
1242936, 4368756
1, 0
1, 0

und natürlich geht dann auch das malen schief...

wo ist der fehler im code?

[marabu]

Zitat:

Zitat von glkgereon

Delphi-Quellcode:

procedure AddNode(Parent: Pointer; PX, PY, Count: Integer);
var 
  Temp: TNode;
  i: Integer;
begin 
  for i := 1 to Count do begin 
    Temp.ChildCount:=StrToInt(InPutBox('Childs','ChildCount','1')); 
    ...

Hi,

du kannst nicht einfach mit Zeigern auf lokale Variablen arbeiten. Die werden vom Laufzeit-Prolog deiner Prozedur auf dem Stack angelegt und verlieren ihre Gültigkeit in dem Augenblick, in dem deine Prozedur verlassen wird.

Versuche die Variable Temp auf dem Heap anzulegen.

Grüße vom marabu

[glkgereon]

Zitat:

du kannst nicht einfach mit Zeigern auf lokale Variablen arbeiten. Die werden vom Laufzeit-Prolog deiner Prozedur auf dem Stack angelegt und verlieren ihre Gültigkeit in dem Augenblick, in dem deine Prozedur verlassen wird.

asooo....

Zitat:

Versuche die Variable Temp auf dem Heap anzulegen.

wie geht das?
"heap", schon mal gehört, aber mehr auch nicht....

EDIT:

also globale variablen nehmen?
wie soll ich das am besten machen?

[marabu]

Zitat:

Zitat von glkgereon

wie soll ich das am besten machen?

Das ist eine philosophische Frage. Auf jeden Fall sollst du globale Variablen vermeiden, wo du kannst. Speicher auf dem Heap kannst du dir mit New() besorgen. Du solltest ihn dann später mit Dispose() wieder freigeben.

Delphi-Quellcode:

type
  PNode = ^TNode;
var
  node: PNode;
begin
  New(node);
  ...
  Dispose(node);
end;

Da du gefragt hast, wie du es am BESTEN machen kannst: Dein Code schubst Bits im Speicher hin und her. Wenn du chemische Strukturformeln zeichnen möchtest, dann wäre es schön, wenn man das am Vokabular erkennen könnte. Ich würde da Molecule, CH4, Bindung erwarten und nicht Baum, Knoten, etc.
Du solltest versuchen die Problemsphäre mehr von der Implementierung zu trennen. Am leichtesten geht das mit OOP-Sprachmitteln, aber ich möchte dich nicht zu sehr verwirren.

Die Liste als Speicherstruktur für dein Alkan-Molekül dürfte nicht ganz angemessen sein, da du ohne Bindungsparameter keine Isomere beschreiben kannst.

Grüße vom marabu

[glkgereon]

also, das ganze ist so gedacht:

jeder Node repräsentiert ein C-Atom.
die Childs beschreiben weitere C-Atome, Parent den Ursprung.

alle übrigen Childs sollen mit H-Atomen aufgefüllt werden beim zeichnen.

so dass zb folgendes

Code:

    H   H   H   H
    |   |   |   |
H - C - C - C - C - H
    |   |   |   |
    H   H H-C-H H
            |
            H

diese Nodes ergibt:

Code:

Pointer | Parent | Childs | ChildCount
1       | 0      | 2      | 1
2       | 1      | 3      | 1
3       | 2      | 4,5    | 2
4       | 3      | 0      | 0
5       | 3      | 0      | 0

[marabu]

Hast du irgenwelche Einschränkungen im Hinblick auf die Isomerie gemacht? Ansonsten hier ein paar Testfälle für deinen Lösungsansatz. Ich habe die Wasserstoffbrücken weggelassen.

3,4-DiMethylHeptan

Code:

C - C - C - C - C - C
    |   |
    C   C
    |     
    C

CycloButan

Code:

C - C
|   |
C - C

Grüße vom marabu

[glkgereon]

nein, es soll keine einschränkung in der isomerie geben.

Cyclo-Alkane sind ein sonder-fall den ich (zunächst) nicht aufnehmen will.

Zitat:

Die Liste als Speicherstruktur für dein Alkan-Molekül dürfte nicht ganz angemessen sein, da du ohne Bindungsparameter keine Isomere beschreiben kannst.

doch wie soll ich das jetzt organisieren?

[marabu]

Zitat:

Zitat von glkgereon

doch wie soll ich das jetzt organisieren?

Nachdem ich nun schon erraten habe, was du als Ausgabe produzieren möchtest, könntest du einmal verraten, wie die Eingabe aussehen soll. Mir schwebt da der Name des Alkans nach der Genfer Nomenklatur vor. Aber vielleicht hast du eigene Vorstellungen?

Für wen möchtest du das Programm schreiben? Nur für dich oder sollen auch andere Benutzer damit umgehen können? Welche Kenntnisse kannst du bei den späteren Benutzern voraussetzen?

Oder ist das eine gestellte Aufgabe mit vorgegebenem Schwerpunkt - z.B. unbedingt keine OOP Sprachmittel und nur statische Speicherstrukturen verwenden?

Ich sollte darüber etwas mehr wissen, damit ich dich nicht aus Versehen in die Wüste schicke.

Grüße vom marabu

[jfheins]

Wenn du Strukturformeln beschreiben willst, da hab' ich mir hier schon Gedanken gemacht.

Wie das dann mit dem Zeichnen aussieht, kann ich dir aber nicht sagen ...

[glkgereon]

also:

ich habe nichts gegen OOP, also gerne als Klasse verpackt.

als eingabe hatte ich mir folgendes vorgestellt (weiss noch nicht ob und wie zu machen):
eine TPaintBox mit PopUpMenu
es wird ein ursprungs-C erstellt
auf rechtsclick wird geprüft ob der mauszeiger auf nem C ist, wenn da dann wird ein Menü gezeigt "Neue Verbindung", "Löschen", etc.
alles soll über dieses Menü gemacht werden (können)



zur speicherstruktur habe ich wie gesagt keine gute idee, daher meine frage.
den link werde ich mir ansehen...

[marabu]

Verstehe ich das richtig? Du willst ein Molekül interaktiv entwerfen und dann speichern? Das mit dem interaktiven Entwurf ist sicher eine interessante Programmieraufgabe, aber besonders realitätsnah ist das wohl nicht. Vielleicht kann ich dich für eine andere Form der Eingabe begeistern.

Chemiker möchten Moleküle gerne in extrem kompakter Form beschreiben (Stichwort SMILES). Dabei werden Moleküle durch Strings dargestellt. Ein SMILES-Parser ist allerdings für deine Alkane overkill. Nehmen wir nochmal 3,4-DiMethylHeptan. Eine mögliche String-Darstellung für das weiter oben abgebildete Molekül wäre dann:

Code:

1CCC(1C)3C(3C)CCC

Daraus kannst du die zweidimensionale Darstellung der Strukturformel erzeugen. Die Ziffern geben die Anzahl von 90-Grad Drehungen gegen den Uhrzeigersinn an. Das C kannst du dir bestimmt denken. In runden Klammern werden die Nebengruppen spezifiziert, danach gilt wieder die Richtung, die vorher eingestellt war. Die Grundstellung ist auf 0 Grad.

Wenn du diese String-Darstellung verwendest, dann kannst du recht bequem deine Moleküle über eine InputBox eingeben. Dein Programm kann den korrekten Namen nach der Genfer Nomenklatur automatisch erzeugen und die Strukturformel in der Paintbox darstellen. Gespeichert werden muss nur der String.

Was hältst du davon?

[glkgereon]

nur um ein molekür darzustellen muss man wieder erst diese abkürzung rausfinden.

diese "interaktive methode" wäre imho komplett intuitiv zu bedienen...(ausserdem reizt es mich einfach ;) )

und alles in nem string zu speichern....man muss für jedes zeichnen etc. alles wieder herausparsen....

[marabu]

Okay - dann bist du jetzt dran. Du benötigst eine bijektive Abbildung, denn du willst ja nicht nur speichern, sondern später das gespeicherte wieder einlesen um das Bild in der Paintbox neu zu erstellen. Eine interessante Aufgabe, die du dir da gestellt hast. Bin gespannt auf deine Lösung.

[glkgereon]

Zitat:

u benötigst eine bijektive Abbildung

was bitte?

das ist ja mein problem.
wie soll ich es speichern? das ist meine frage!!!

[marabu]

Überlege doch einmal: ein Baum ist wohl eher ungeeignet, da Alkane keine typische Baumstruktur haben. Du musst auf jeden Fall unterscheiden zwischen interner Repräsentation und externem Speicherformat.

Als erstes solltest du dir eine Klasse TAlkan definieren. Überlege was die Kerneigenschaften eines Alkans sind - z.B. Name, Hauptkettenlänge. Dann hast du Ethyl- und Methyl-gruppen, die du wieder als Klassen definieren kannst. Die haben auch wieder Kerneigenschaften, z.B. den C-Index, Kettenlänge.
Überlege dir welche Felder direkt veränderbar sein sollen. Das werden die properties mit ihren Get- und bzw. oder Set-Methoden.

Du wirst Methoden brauchen um die Nebengruppen einzufügen und wieder zu entfernen. Du wirst die Methoden Load und Save brauchen um die Persistenz zu gewährleisten. Und nicht zuletzt wird deine Alkan-Klasse eine Methode Draw haben, um sich in einer Paintbox darzustellen.

Wenn du willst, kannst du die Persistenz solange ausklammern, bis der Rest funktioniert. Die Speicherung als String - wie ich sie dir in Vereinfachung an SMILES angeboten habe, scheint dir trotz der offensichtlichen Vorteile nicht zu behagen. Du könntest eine eigene XML-Sprache entwickeln um deine Klasse persistent zu machen. Natürlich kannst du deine Objekte auch binär in einen Stream schreiben, aber die textuelle Darstellung halte ich bei deinem Projekt für angemessener.

Fang einfach an.

PS: bijektive Abbildung heißt in diesem Kontext, dass das am Bildschirm gestaltete Alkan nach Speicherung und erneutem Laden genau gleich wieder dargestellt werden kann. Dein Speicherformat muss jeden Informationsverlust vermeiden.