Verkettung ? Fragen für Info-Klausur

[VeeJay]

Hallo,
wir schreiben am 10.01. eine Informatik-Klausur und bis dahin müssen wir das Prinzip der Verkettung verstanden haben. Leider habe ich das Wort "Verkettung" in keinem einzigen Forum gesehen und darum wollte ich fragen ob mir jemand von euch das Prinzip der Verkettung erklären kann
und wofür man sachen wie "new(a)" oder "a^:='B'" braucht.

Delphi-Quellcode:

Type pointertyp=^char;
Var a,b,c,d,e,f,hilf :pointertyp;

Procedure Zeigerchaos;
Var s:string;
Begin

new(a);new(b);new(c);
new(d);new(e);new(f);

a^:='B';
b^:='a';
c^:='s';
d^:='i';
e^:='c';

form1.edit1.text:=a^+b^+c^+d^+e^;

new(a); a^:='P';
hilf:=e;
e:=b;
d:=hilf;
f^:='l';

form1.edit2.text:=a^+b^+c^+d^+e^+f^;
end;

[Hansa]

suche mal nach "verkette Liste" oder Pointer

Gruß
Hansa

[Sebastian Nintemann]

Hallo und herzlich willkommen!

Zitat:

Zitat von VeeJay

...und wofür man sachen wie "new(a)" oder "a^:='B'" braucht.

Erst einmal dazu:

Code:

new(a);

Dies reserviert den Speicher für eine neue, dynamische (weil zur Laufzeit erstellte) Variable, sie reserviert so viel Speicher, wie der Typ auf den der Zeiger a zeigt braucht. Ein Zeiger (Pointer) beinhaltet ja nur die Adresse im Speicher einer bestimmten Variable. Damit zeigt a jetzt auf eine Variable, auf die mit a^ (Dereferenzierungsoperator) zugegriffen werden kann.
Mit

Code:

a^ := 'B';

weist du also dem Speicher auf den a zeigt den Inhalt 'B' zu.

Aber es fehlt in der procedure die freigabe des reservierten Speichers, bei dynamischen Variablen macht Delphi das nämlich nicht automatisch, wie bei zB lokalen Variablen!

Zitat:

Zitat von Delphi OH

When an application is finished using a dynamic variable created with New, it should dispose of the memory allocated for the variable using the Dispose standard procedure.

Also wenn man mit der Arbeit mit einer mit new() erzeugten Variable fertig ist oder eine neue Variable mit a erschaffen werden soll muss man den Speicher mit

Code:

dispose(a);

erst wieder freigeben.

Ich hoffe das war jetzt ein bisschen verständlich :hi:

Gruß, Sebastian

[VeeJay]

Danke erstmal ;)
Also wenn ich das jetzt richtig verstanden habe ist die "Verkettung", das Prinzip, womit man erweiterbare Datenbanken machen kann, weil man mit new(xyz) immer neue Glieder erstellen kann. Und wenn man auf dieses neue Glied zugreifen will, muss man xyz^ benutzen ?

Ich hoffe mal das stimmt so. Dann wäre das ganze nämlich gar nicht sooo schwer.

Kann mir vielleicht noch jemand von euch ein kleines einfaches Beispiel für eine dynamische verkettete Datenbank geben?

[Sebastian Nintemann]

Hallo VeeJay, was jetzt beau mit Verkettung gemeint ist kann ich dir nicht sagen, da ich den Begriff so nicht kenne. Auf die neu erstellten Daten musst du aber, wie du richtig gesagt hast mit

Delphi-Quellcode:

xyz^

zugreifen, der ^-Operator dereferenziert den Zeiger, man erhält also mit a^ den Speicherinhalt der an der Adresse a steht.
Gruß, Sebastian

[Christian Seehase]

Moin VeeJay,

also irgendwie komme ich dabei in's Schleudern, wenn ich mir auf der einen Seite Dein Sourcecodebeispiel ansehe, und dann auf der anderen Seite etwas von Verkettung bei Datenbanken höre.

Im zweiten Falle würde ich, wie Hansa auch, an den Begriff verkettete Listen denken.

Das dahinterstehende Prinzip ist recht einfach:

Jeder Datensatz in einer Datei fängt an einem Bestimmten Byte relativ zum Dateianfang an.
Das heisst, der erste Satz fängt immer am Offset (Dateibeginn + Offset = Position in der Datei) 0 an.
Ist die Datei als verkettete Liste aufgebaut, enthält jeder Satz auch noch den Offset des in der logischen Reihenfolge als nächstes kommenden Datensatzes. Ist dieser Wert z.B. 0 oder ein besonderer Wert, der real nicht vorkommen kann, oder entsprechend festgelegt wird, hat man das Ende der Liste erreicht.
Durch diese Methode ist es dann relativ einfach, eine Satz in der logischen Reihenfolge einzufügen.
Man schreibt ihn an das Ende der Datei, sucht den Satz, der vor diesem kommen muss, merkt sich den Offset des Folgesatzes, und ersetzt ihn durch den des neu hinzugefügten.
Anschliessend, wird dann der gespeicherte Offset des Folgesatzes in das dafür vorgesehene Feld des neuen Satzes geschrieben und fertig.
Löschen geht dann ahnlich (Offset des dem zu löschenden Datensatzes folgenden Satzes in den des vorher kommenden schreiben)
Dadurch entstehen dann, mit der zeit Dateien, die auch viel Datenmüll enthalten, und die man deshalb gelegentlich, komprimieren muss.

Schneller geht's dann mit doppelt verketteten Listen, wo jeder Eintrag den Offset des folgenden und den des vorhergehenden erhält.

Wenn man statt des Offsets Indizes verwendet kann man mit diesem Prinzip auch Arrays verwalten.

[Chewie]

Wenn ich mich nicht irre, hab ich das mal auf Bayern-Alpha (IT-Kompaktkurs) gesehen. Bei C++ benutzt man die Verkettungen, weil es keine Listen gibt, deren Größe man zur Laufzeit ändern kann. Bei Pascal gibt es dies aber (SetLength bei dyn. Arrays) und die Verkettung ist deshalb nicht unbedingt notwendig.
Oder verwechsle ich da jetzt was?

[Hansa]

Hi,

Zitat:

Zitat von Chewie

Wenn ich mich nicht irre...... Bei C++ benutzt man die Verkettungen, weil es keine Listen gibt, deren Größe man zur Laufzeit ändern kann....Oder verwechsle ich da jetzt was?

Uff, das Prinzip der verketteten Listen ist meines Wissens in C weit verbreiteter, als in Pascal, bzw. Delphi. Falls nicht, kommt hoffentlich ein Kommentar.

Gruß
Hansa

[fiasko]

Zitat:

Zitat von Chewie

Wenn ich mich nicht irre...... Bei C++ benutzt man die Verkettungen, weil es keine Listen gibt, deren Größe man zur Laufzeit ändern kann....Oder verwechsle ich da jetzt was?

Soweit ich weiß, sind dynamische Array gerade in der C Welt sehr beliebt. Es läßt sich damit wesentlich einfacher als unter Pascal & Co. umgehen (da ist einfach jeder Zeiger ein Zeiger auf ein Array, und ein Array automatisch ein Zeiger).

Der Quelltext vom ersten Posting sieht aber nich so aus, als sollte hier irgendwas mit dyn. Listen oder Arrays gemacht werden. Auf mich hat das eher so den Eindruck das der Lehrer hier das verknüpfen der Char-Zeiger und was dann nach den lustigen Wertzuweisungsspielchen herauskommt meint.


Thomas

[Hansa]

Hi,

Zitat:

. Auf mich hat das eher so den Eindruck das der Lehrer hier das verknüpfen der Char-Zeiger und was dann nach den lustigen Wertzuweisungsspielchen herauskommt meint.

So isses. Die fangen immer so an. :mrgreen: Es geht um verkettete Listen. Ein Pointer (Zeiger) hat immer mindestens zwei Bestandteile : den Inhalt und die Adresse des nächsten Listen-Elementes. Dies hat wieder einen Inhalt und die Adresse des nächsten usw. Wer das durchschaut hat, kann auch den Zeiger an das Anfangselement zurückgeben, das wäre dann sozusagen ein Kreis. Aber ein Anfang muß auch her : NIL. Will nicht wissen, wieviele mit NIL operieren, ohne zu wissen, was das ist. Soviel von mir.

Gruß
Hansa

[Hansa]

Hi,

Zitat:

und darum wollte ich fragen ob mir jemand von euch das Prinzip der Verkettung erklären kann
und wofür man sachen wie "new(a)" oder "a^:='B'" braucht.

new ist ja schon erklärt. dispose ist das Gegenteil davon. Pass aber verdammt auf, daß Du a^ und ^a nicht verwechselst, also ob das ^ vor oder hinter dem Bezeichner steht ! Das ist ein himmelweiter Unterschied. Mit a^ kriegst Du den Inhalt des Speichers (siehe oben) an der Stelle a direkt. ^a aber ist die Stelle an der der Inhalt des Zeigers liegt !!! Stimmt das überhaupt ? Vorsichtshalber : ohne Gewähr.

Gruß
Hansa

P.S.: Wann ist die Klausur ?

[VeeJay]

Das mit dem "Wortspiel" hab ich jetzt verstanden und ich bin bei der erweiterten Version und brauche wohl wieder Hilfe :?
Also:

Delphi-Quellcode:

Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   next : pKette;
                 END;

...das OOP hab ich ja eigentlich drauf, aber das verstehe ich nicht ?
Wäre gut wenn mir jemand erklären könnte warum ein Typ pkette eine Eigenschaft, die auch pkette heißt, haben kann und vielleicht auch alles andere an dem Type. :lol:

Danke nochmal für alles, was ihr mir bis jetzt erklärt habt ;)

[Hansa]

Hi,

aha, bist auch noch dran. Wie ich sehe läuft das auf meine Vermutung mit der verketteten Liste hinaus. Konnte fast nur so sein.

Zitat:

Zitat von VeeJay

Delphi-Quellcode:

Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   
                   next : pKette;
                 END;

...das OOP hab ich ja eigentlich drauf, aber das verstehe ich nicht ?

Wann ist die Klausur ? Das frage ich nicht umsonst ! Ist sie nächste Woche, kannst Du das hier getrost vergessen. Nun gut :

1. Dein Quelltext war für diese Zwecke unleserlich, was nur bedeutet, daß wort und next in einer Zeile stehen. Kleine Ursache, aber große Wirkung.

2. vergiß OOP, das hat in diesem Zusammenhang nichts zu bedeuten.

3. next reicht den Zeiger an das nächste Element, welches wiederum vom Typ pKette ist und auch einen Inhalt hat. Mit Inhalt sind die Daten gemeint ("wort") ! Zusätzlich das nächste Element wieder ein next, nämlich das des nächsten Elementes.

Tip : vergiss in diesem Zusammenhang alles, was Du über Delphi weißt. Das ist für jede Programmiersprache gültig. Ähm, wann ist nochmal die Klausur ?

Gruß
Hansa

[VeeJay]

Die Klausur ist am 10.01.
Unser Info-Lehrer war so freundlich uns all die Sachen
über die Ferien auf zu geben. Wir hatten nur 1 Stunde Unterricht
darüber. Und in der haben wir das Beispiel ganz oben gemacht.
Was ich hier poste ist vielleicht ein Achtel von allem, was wir noch
machen müssen :P

Meinst du das krieg ich noch hin, zumindest mit den verketteten Listen?

Hier ist noch der restliche Code:

Delphi-Quellcode:

unit Unit1;   //Zeiger_verkett1 (ohne Verkettungsprozedur)
// Aufgaben: 1) Erkläre den Datentyp "knoten" (siehe unten)
//           2) Welche Ausgabe ist am Ende in Edit1.Text zu erwarten?
//           3) Was versteht man bei der Reihenfolge der Daten unter LIFO ?
//           4) Welche Vorteile bringt die dynamische Verkettung von Daten?
interface

uses  Windows, Messages, SysUtils, Classes, Graphics,
      Controls, Forms, Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
  public
  end;

var
  Form1: TForm1;
  Satz : string;

implementation {$R *.DFM}
//---------------------------------------------------
Type pkette = ^knoten;         // p steht für Pointer
     knoten    = RECORD
                   wort : string;   next : pKette;
                 END;
//---------------------------------------------------
Var kette: pKette;

procedure TForm1.Button1Click(Sender: TObject);
Var neu, hilf :pKette;
begin
  kette:=nil;    //Die Kette erhält einen Anfang
  satz:='';

  New(neu);      //Ein neues Kettenglied wird erzeugt
  neu.wort:='Das ';
  neu.next:=kette;
  kette:=neu;    //...und angehängt

  New(neu);      //...noch ein Kettenglied
  neu.wort:='wars ';
  neu.next:=kette;
  kette:=neu;

  New(neu);     //...und noch eines
  neu.wort:='schon ';
  neu.next:=kette;
  kette:=neu;
  {---------------------------------------------}

  satz:=kette^.wort;    // Die Kette wird ausgelesen

  {Wenn wir den Kettenzeiger nicht verändern und statt-
  dessen den Hilfzeiger, können wir den Anfang der
  Kette stets wiederfinden!}

  hilf:=kette^.next;    // Zum nächsten...
  satz:=satz+hilf^.wort;

  hilf:=hilf^.next;     // Zum nächsten...
  satz:=satz+hilf^.wort;

  edit1.text:=satz;     // Ausgabe am Bildschirm

end;

end.

[Hansa]

Hi,

Zitat:

Meinst du das krieg ich noch hin, zumindest mit den verketteten Listen?

Ehrlich gesagt : Glaub es nicht. :? Das hat aber mit Dir nichts zu tun. Aber in einer Woche ist das nicht zu schaffen. Das ist pure Theorie. Da nützt Dir kein Delphi und die beste VCL auch absolut nichts. Warum machen die Heinis das wohl erst ganz am Schluß? Weil sie selber keine Ahnung haben. Bei starken Nerven : Schreibe in der Klausur in einem gewissen Zusammenhang

Code:

a^ := next; x := a;

usw., wahrscheinlich guckt der nur nach ; := und so. Der ist viel zu faul, alles durchzugehen.

Gruß
Hansa

P.S.: Auf keinen Fall würde ich wegen dieses Themas etwas anderes vernachlässigen. Vermute fast, daß eine Aufgabe mit Pointern überhaupt nicht kommt.

[Christian Seehase]

Moin VeeJay,

1. Der Datentyp Knoten ist ein Recordtyp mit zwei Datenfeldern.
   Zum einen einem string mit der Bezeichnung Wort, und zum anderen mit einem Zeigertyp auf den Typ Knoten und der Bezeichnung next.
2. schon wars Das
3. LIFO steht für Last In First Out
   Auf das was als letztes hinzugefügt wird, wird als erstes wieder zugegriffen.
   Paradebeispiel: Tellerstapel
   Der Teller den man zuletzt draufgelegt hat, wird man wohl, aller voraussicht nach, als erstes wieder herunternehmen.
4. Wie ich oben schon geschrieben hatte:
   Man kann problemlos neue Daten einsortieren (hinzufügen), ohne die gesamten Daten umsortieren zu müssen, ebenso problemlos lassen sich Daten auch löschen, indem einfach nur der Zeiger auf ein Element auf das dem zu löschende Folgende gesetzt wird

Bestimmt werden diese Ausführungen noch ergänzt werden ;-)

Anmerkung:
Wenn das Beispiel von Deinem Lehrer stammt, dann hat er es aber inkonsequent geschrieben.
Entweder er schreibt den dereferenzierungsoperator ^ immer mit oder nie, aber nicht mal so und mal so.
Eigentlich müsste jede neu.xxxx neu^.xxxx geschrieben werden, oder statt kette^.xxxx und hilf^.xxxx kette.xxxx und hilf.xxxx.
Aber dieser, unnötige, Wechsel kann doch recht verwirrend sein.

Das Weglassen funktioniert aber auch nur, weil der Compiler clever genug ist zu wissen was gemeint ist, wenn man neu.wort schreibt (und das ^ weglässt)

[Hansa]

Hi VeeJay,

Christian Seehase hat eine ähnliche Vermutung, wie ich. Der hat nicht viel Ahnung. Liest Du seinen Kommentar, verstehst Du hoffentlich, warum ich frage, wann die Klausur ist ? Also : Pokerspieler (J/N) ? Falls ja : mit Antworten bluffen, falls Nein : vergiss es. Ansonsten kann ich Dir nicht mehr viele Tips geben.

@Christian Seehase : @VeeJay : hier nicht weiterlesen, das verwirrt Dich nur. :!: Was ist mit doppelt-verketteten Listen oder zyklische, die ich schon angedeutet habe ?

Gruß
Hansa[/quote]

[fiasko]

Auch wenn das Posting schon ein Stück weiter oben steht...

Zitat:

Zitat von Hansa

Pass aber verdammt auf, daß Du a^ und ^a nicht verwechselst, also ob das ^ vor oder hinter dem Bezeichner steht ! Das ist ein himmelweiter Unterschied. Mit a^ kriegst Du den Inhalt des Speichers (siehe oben) an der Stelle a direkt. ^a aber ist die Stelle an der der Inhalt des Zeigers liegt !!! Stimmt das überhaupt ?

Ne stimmt nich. Man kann sich in Delphi zwar vieles erlauben (z.B. den Derefenzierungsoperator ^ bei Zugriff auf record-Elemente weglassen), aber der Referenzierungsoperator ist bei Pascal schon immer ein @ (und dann hat man noch irgendwann die Funktion Addr() eingeführt). Natürlich bissl verwirrend, das aber nur in der Typedef ein ^ davor kommt (dafür darf aber keins dahinter stehen :-).


Thomas

[VeeJay]

Also bei aller Schwierigkeit,
ich denke, ich weiß jetzt schon eine Menge mehr über das Thema als ich noch vor 2 Tagen wusste. Ist echt cool, dass ihr mir das alles zeigt. Ich werde morgen noch mal alles zusammenfassen und gucken ob ich noch Probleme mit bestimmten Sachen habe, die unbedingt noch gelöst werden müssen. Ansonsten werde ich das Prinzip wohl auswendig lernen ohne es zu verstehen :roll:
Vielleicht kann mir auch noch jemand den Zusammenhang zwischen a^ und @a
erklären....

Dann bis morgen

[Christian Seehase]

Moin VeeJay,

mit Zusammenhang wird's schwierig ;-)

Ich hab' Dir hier mal ein "wildes" Beispiel zusammengestellt:
(um das try/finally brauchst Du Dich erstmal nicht zu kümmern, auch wenn's wichtig ist)

Delphi-Quellcode:

var
  p : PChar; // Pointer auf Char
  c : Char;  // Ein Character

begin
  p := AllocMem(1); // Speicher reservieren und Adresse dieses Speichers nach p
  try
    p^ := 'a';      // Jetzt an diese Stelle ein Zeichen schreiben.
    c  := p^;       // und jetzt dieses Zeichen an die Charactervariable übergeben
    ShowMessage(c); // Anzeigen, dass es auch geklappt hat
  finally
    FreeMem(p,1);   // Nun kann der Speicher wieder freigegeben werden
  end;
  p  := @c;         // Jetzt die Adresse der Charactervariablen nach p
  ShowMessage(p^);  // Und sich das a anzeigen lassen
  c  := 'b';        // Jetzt ein anderes Zeichen in der Charactervariablen speichern
  ShowMessage(p^);  // aber wieder anzeigen lassen, auf was p zeigt... siehe da es erscheint ein b
end;

War das soweit verständlich mit ^ und @ ?

[Hansa]

Zitat:

Zitat von VeeJay

Ansonsten werde ich das Prinzip wohl auswendig lernen ohne es zu verstehen :roll:

Ja, wohl oder übel. Obwohl es Dir nichts nützen wird. Falls eine solche Frage kommt, macht sie höchstens 10% der Punkte aus. Kümmere dich besser um die restlichen 90% :!:

Gruß
Hansa

[Salomon]

Hallo,
mit deinem Wissen über Pointer, kannst du nun auch einfache verkette Listen erstellen. Wichtig für Ketten sind die While Schleifen, die du bei fast allen Aktionen brauchst (z.B beim Einfügen, Löschen und durchsuchen der Kette)

Delphi-Quellcode:

Type 
   pElementZeiger := ^tElement;
   tElement := object
                 next  :tElementZeiger;
                 inhalt: integer;
               end;

Var
kopf : pElementZeiger; //Globale Variable die immer auf das erste Element der Liste zeigt.

Einfügen in die Liste geht dann z.B so:

Delphi-Quellcode:

Procedure InsertNewElement (content : integer);
Var hilf, newelement : pElementZeiger;
Begin
hilf := kopf^.next;
while (hilf<>nil) do 
 hilf := hilf^.next; //mit der Schleife kommt man ans Ende der Liste, wo dann das neue Element eingefügt wird

new(newelement);
newelement^.inhalt := content;
newelement.^next := nil;
hilf^.next := newelement;
end;

Das Ausgeben der Liste ist genauso einfach:

Delphi-Quellcode:

Procedure ShowList;
Var hilf :pElementZeiger;
Begin
hilf := kopf;
while (hilf^.next <> nil) do
 begin
  memo1.lines.Add (inttostr(hilf^.inhalt));
  hilf := hilf^.next;
 end;
end;

Suchen funktioniert ebenfalls mit der Schleife:

Delphi-Quellcode:

Procedure FindElement (content : integer);
Var hilf : pElementZeiger;
Begin
hilf := kopf;
while (hilf <> nil) do 
 begin
  if hilf^.inhalt = content then
   showmessage('Element gefunden: ' + inttostr(hilf^.inhalt));
   hilf := hilf^.next;
 end;
end;

Das löschen eines Elementes in der Liste ist schon komplizierter, da man darauf achten muss, dass die Zeiger später wieder auf die richtigen Elemente Zeigen und die Kette nicht auseinander bricht.

Delphi-Quellcode:

Procedure LoescheElement (content : integer);
Var hilf1, hilf2 : pelementZeiger;
Begin
Hilf1 := Kopf;
If Kopf^.inhalt = content then
 begin
  Kopf := Kopf^.next;
  Dispose (hilf1);
 end
else
 Repeat
  hilf2 := hilf1; hilf1 := hilf1^.next;
 Until (Hilf1 = nil) or (Hilf1^.inhalt = content);

If Hilf1 <> nil then
 begin 
  Hilf2^.next := Hilf1^.next;
  Dispose (Hilf1);
 end;
end;

So, ich denke das ist schonmal ein kleiner Überblick wie man mit einfach verketten Listen arbeitet. Doppelt verkette Listen haben nicht nur einen Zeiger auf das Nachfolge Elemnet, sondern auch einen Zeiger auf ihren Vorgänger. Dadurch werde Opperationen wie z.B das Löschen einfacher.
Die Quelltexte können Fehler beinhalten, da ich sie eben so aus dem Kopf aufgeschrieben habe. Ist schon wieder etwas her wo ich mich mit Listen beschäftigen musste.

Mfg Salomon

[Neotracer64]

Ich bin auch gerade dabei mich mit Listen zu beschäftigen. :)

Ich habe versucht das wie folgt umzusetzen, orientiert an dem Code über mir:

Delphi-Quellcode:

PZahl = ^TZahl;
TZahl = record
   Item  : Integer;
   Next  : PZahl;
end;


type
  TintList = class
  Zahl : TZahl;
  PFirst : PZahl;
  constructor Create;
  procedure Add(Int: Integer);
  //procedure Delete(Index: Integer);
  //function  Get(index: Integer): Integer;
end;

...

constructor TintList.Create;
begin
  inherited Create;
  Zahl.Item := 0;
  Zahl.Next := nil;
  PFirst := @Zahl;
end;

...

procedure TintList.Add(int: Integer);
var
  Digit: PZahl;
  Silk : PZahl;
begin

  //Silk := PFirst^.next;  <-- IST FALSCH!!!!
    Silk := PFirst; 


  If Silk <> nil Then
     while (Silk^.Next <> nil) do
        Silk := Silk^.next;

  New(Digit);
  Digit^.Item := int;
  Digit^.Next := nil;
  Silk^.Next := Digit; /// <--- Hier WAR er abgestürzt jetz gehts wieder...
end;

Nur wenn ich eine Zahl zu der Liste hinzufügen möchte, stürzt er Mit EAccessViolation ab. :(. An der Adresse 00000004 kann er nicht schreiben steht dann zusätzlich da.

Aber eigentlich sollte die Routine einfach das letzte Element finden, was dann ja Silk sein soll. Und das darf unmöglich auf 00000004 zeigen. :shock:

Wie kann das denn sein. Ich blic da nich durch :cry:

EDIT: Habs rausgefunden. Ich habe es oben korrigiert und die falsche Zeile auskommentiert.