Einträge nicht nur aus Listbox entfernen

[jawo3]

Hallo,
ich habe vor einigen Tagen schon mal eine Frage zu meinem derzeitigen Programm gestellt und ihr konntet mir schnell und kompetent weiterhelfen. Leider bin ich jetzt auf ein neues Problem gestoßen, dass wieder damit zusammenhängt, dass ich mich noch nicht so gut mit Zeigern auskenne, was sich hoffentlich bald ändern wird.

Es geht erneut um das "Vokabel-Programm" in dem Wörter abgespeichert werden sollen und diese dann in einer ListBox ausgegeben werden. Ich arbeite gerade daran, dass Wörter innerhalb der ListBox mit der Maus markiert werden, und nach Klick auf einen Button aus der ListBox entfernt werden. Das funktioniert soweit auch sehr gut. Das Problem ist nur, dass die Wörter nicht aus meiner Zeigerstruktur entfernt werden, sondern nur aus der ListBox. Das heißt, wenn ich den "Einträge Anzeigen" Button drücke, erscheinen alle EInträge erneut in meiner ListBox, inklusive derjenigen, die eigentlich schon hätten gelöscht werden sollen.

Ich weiß leider nicht sorecht, wie ich das Problem beheben kann. Vielleicht könnt ihr mir ja ein bisschen auf die Sprünge helfen, dass wäre sehr nett.

Hier mal das Programm. Die Stelle, an der ich gerade arbeite, habe ich mit einem Kommentar-Block versehen:

Delphi-Quellcode:

unit Vokabeln;

interface

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

type
    TForm1 = class(TForm)
      Label1: TLabel;
      EditEintragen: TEdit;
      ListBoxAnzeige: TListBox;
      ButtonEintragen: TButton;
      ButtonEntfernen: TButton;
      ButtonAnzeigen: TButton;
      RadioButtonLIFO: TRadioButton;
      RadioButtonFIFO: TRadioButton;
      ButtonLeeren: TButton;
      ButtonSpeichern: TBitBtn;
      ButtonLaden: TBitBtn;
      ButtonBeenden: TBitBtn;
      ButtonMarkieren: TButton;
      procedure ButtonBeendenClick(Sender: TObject);
      procedure ButtonEintragenClick(Sender: TObject);
      procedure ButtonEntfernenClick(Sender: TObject);
      procedure ButtonSpeichernClick(Sender: TObject);
      procedure ButtonLadenClick(Sender: TObject);
      procedure ButtonAnzeigenClick(Sender: TObject);
      procedure FormActivate(Sender: TObject);
      procedure EditEintragenKeyPress(Sender: TObject; var Key: Char);
      procedure ButtonLeerenClick(Sender: TObject);
      procedure SpeicherFreigeben;
      procedure ListBoxAnzeigeKeyDown(Sender: TObject; var Key: Word;
      Shift: TShiftState);
      procedure RadioButtonFIFOClick(Sender: TObject);
      procedure RadioButtonLIFOClick(Sender: TObject);
    procedure ButtonMarkierenClick(Sender: TObject);
    end;
    Zeiger = ^Element;     //Definition eines Zeigertyps
    tInhalt = string[15];
    Element = record
                naechster: Zeiger;
                Inhalt: tInhalt;
              end;

const Datenpfad='Vokabeln.dta';             //Hier wird die Datenbank gespeichert

var
  Form1: TForm1;
  Wurzel, z : Zeiger;                       //nötig um Liste aufzubauen
  f: file of tInhalt;                       //nötig für Speicher-/Ladevorgang

function Kontrolle:Boolean;

implementation

{$R *.dfm}

procedure TForm1.FormActivate(Sender: TObject);   //Bei Programm-Start
begin
EditEintragen.SetFocus;       //Fokus auf Eintragen-Textfeld setzen
Wurzel:=nil;   //Wurzel markiert erstes greifbares Element und wird zunächst "geerdet"
end;

function Kontrolle;   //Test auf gängigste IO-Fehler
begin
  result := false;
  case IOResult of
     0: result := true;
     2: begin showmessage ('Datei nicht vorhanden.' +#13+ 'Datei wird angelegt');
          rewrite(f);
          result := true;
        end;
     3: showmessage ('Ungueltiger Dateiname/Pfad');
     5: showmessage ('Dateizugriff verweigert.');
    21: showmessage ('Laufwerk nicht bereit!');
  end;
end;

procedure TForm1.EditEintragenKeyPress(Sender: TObject; var Key: Char);   //Eintragen über Enter Taste
begin
if (Key=#13) and (length(EditEintragen.Text)<>0) then
  begin
      Key:=#0;
      ButtonEintragenClick(Sender);     //Wenn "Enter" gedrückt wird dann eintragen
      ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
      EditEintragen.SetFocus;           //Fokus auf Textfeld setzen
  end;
end;

procedure TForm1.ButtonEintragenClick(Sender: TObject);    //Vokabeln eintragen
begin
if length(EditEintragen.Text)<>0 then     //Wenn Textfeld nicht leer ist
begin
    New(z);                              //Erzeugen eines neuen Listenelements
    z^.Inhalt:= EditEintragen.Text;      //Record wird befüllt
    z^.naechster:=Wurzel;                //Zeiger "naechster" wird bisheriger Wurzelwert zugewiesen
    Wurzel:=z;                           //Zeiger Wurzel wird auf z "verbogen"
    EditEintragen.Text:='';              //Textfeld wieder leeren
    ButtonAnzeigenClick(Sender);         //Neue Liste anzeigen
    EditEintragen.SetFocus;              //Fokus auf Textfeld setzen
end;
end;

procedure TForm1.RadioButtonFIFOClick(Sender: TObject);
begin
ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
end;

procedure TForm1.RadioButtonLIFOClick(Sender: TObject);
begin
ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
end;

procedure TForm1.ButtonAnzeigenClick(Sender: TObject);    //Prozedur zum Anzeigen der Vokabelliste
begin
if RadioButtonFIFO.Checked then                 //Wenn FIFO-Modus aktiviert...
begin
  ListBoxAnzeige.Items.Clear;                   //Listbox wird zunächst geleert...
  z:=Wurzel;
  while z<>nil do                               //...und mit neuer Liste befüllt
    begin
    ListBoxAnzeige.Items.Insert(0,z^.Inhalt);
    z:=z^.naechster;
    end;
end
else if RadioButtonLIFO.Checked then            //Wenn LIFO-Modus aktiviert...
begin
  ListBoxAnzeige.Items.Clear;                   //Listbox wird zunächst geleert...
  z:=Wurzel;
  while z<>nil do                               //...und mit neuer Liste befüllt
    begin
    ListBoxAnzeige.Items.Add(z^.Inhalt);
    z:=z^.naechster;
    end;
end;
end;

procedure TForm1.ButtonLeerenClick(Sender: TObject);   //Listbox wird geleert
begin
ListBoxAnzeige.Items.Clear;
end;

procedure TForm1.ListBoxAnzeigeKeyDown(Sender: TObject; var Key: Word;   //Entfernen mit Hilfe der "Delete" Taste
  Shift: TShiftState);
begin
if (Key=VK_DELETE) then ButtonEntfernenClick(Sender);   //Entfernen-Button klicken
end;

procedure TForm1.ButtonMarkierenClick(Sender: TObject);   //Prozedur markiert alle Einträge der Listbox
var min, max: integer;
begin
max:=ListBoxAnzeige.Count;
for min:=1 to max do ListBoxAnzeige.Selected[min-1]:=true;
end;

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii : integer;
    letzter : integer;
begin
if ListBoxAnzeige.Count<>0 then
begin
  with ListBoxAnzeige do
  begin
    for ii := -1 + Items.Count downto 0 do
    if Selected[ii] then
    begin
      Items.Delete(ii);
      letzter:=ii;
    end;
  end;
  if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
  ListBoxAnzeige.Selected[letzter]:=true;

//-------------------------------------------------------------------------------------
//----------------------->Schleife, die Änderungen in die Zeigerstruktur übernimmt
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
end;
end;

procedure TForm1.SpeicherFreigeben;      // Speicher für den Zeiger wird freigegeben
var DelPointer : Zeiger;
begin
  while Wurzel <> nil do begin
    DelPointer:=Wurzel;
    Wurzel:=Wurzel^.naechster;
    dispose(DelPointer);
  end;
  Wurzel:=nil;
end;

procedure TForm1.ButtonSpeichernClick(Sender: TObject); //Vokabeldatenbank speichern
var RunPointer : Zeiger;
begin
  Assignfile(f, Datenpfad);
  try
    rewrite(f);
    RunPointer:=Wurzel;
    while RunPointer <> nil do
    begin
      write(f, RunPointer^.Inhalt);
      RunPointer:=RunPointer^.naechster;
    end;
    showmessage('Vokabel-Verzeichnis erfolgreich gespeichert'); //Erfolgsmeldung ausgeben
  finally
    closefile(f);
  end;
end;

procedure TForm1.ButtonLadenClick(Sender: TObject); //Vokabeldatenbank laden
var NewPointer, OldPointer : Zeiger;
begin
  SpeicherFreigeben;
  Assignfile (f, Datenpfad);
  try
    reset(f);
    OldPointer:=nil;
    while not eof(f) do //Auslesen bis Ende der Datei erreicht wird
    begin
      new(NewPointer);
      read(f, NewPointer^.Inhalt);
      NewPointer^.naechster:=nil;
      if OldPointer <> nil then
        OldPointer^.naechster:=NewPointer;
      if Wurzel = nil then
        Wurzel:=NewPointer;
      OldPointer:=NewPointer;
    end;
    ButtonAnzeigenClick(Sender);      //Geladene Liste anzeigen
    showmessage('Datenbank erfolgreich geladen'); //Erfolgsmeldung ausgeben
  finally
    closefile(f);
  end;
end;

procedure TForm1.ButtonBeendenClick(Sender: TObject);   //Programm beenden
begin
  close;
end;

end.

Vielen Dank im Voraus
jawo3

[DeddyH]

Eine Frage vorweg: handelt es sich um eine Hausaufgabe, oder wieso verwendest Du eine einfach verkettete Liste? Da es sich ja eh nur um Strings handelt, könntest Du sonst genausogut eine TStringlist verwenden, das wäre um Längen einfacher. Der Vollständigkeit halber aber hier die Vorgehensweise:
- Durchiterieren der Liste
- wenn Nachfolgeelement das gesuchte ist, dessen Nachfolger merken (1)
- Zeiger auf das Nachfolgeelement merken (2)
- Nachfolger des aktuellen Elements auf gemerkten (1) setzen
- gemerkten Zeiger (2) freigeben

Schau einmal in der Tutorials-Sparte, IIRC gibt es da auch ein Tut dazu, das das Ganze detaillierter beschreibt.

[jawo3]

Hi,
danke für die Antwort. Ja, die einfach verkettete Liste war eine Vorgabe.
Ich werde mal versuchen, das von dir Beschriebene umzusetzen.

Ich melde mich dann nachher nochmal.

Gruß
jawo3

[DeddyH]

Ich würde es übrigens andersherum machen: zuerst aus der verketteten Liste löschen und dann die Listbox komplett neu aus dieser Liste füllen, dann sieht man auch, ob alles funktioniert hat. Wenn es sich nicht um allzuviele Einträge handelt und man BeginUpdate/EndUpdate beim Befüllen der ListBox verwendet, sollte das auch ausreichend performant sein.

[Luckie]

Guck mal hier: http://www.michael-puff.de/Programmi...orials/Listen/

[jawo3]

Ich schau mir das mal an danke...

[jawo3]

Ich habe mir das jetzt so gedacht für den Entfernen-Button, aber leider funktionier das nicht.
Ich erhalte die Fehlermeldung: Invalid Pointer Operation.

Hier der Quelltext zum Entfernen Button:

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii: integer;
    letzter : integer;
begin
  if ListBoxAnzeige.Count<>0 then
  begin
  with ListBoxAnzeige do
      begin
        for ii := -1 + Items.Count downto 0 do
        if Selected[ii] then
        begin
          z:=Wurzel;
            while z<>nil do                               //Schleife, die Änderung in die Zeigerstruktur übernimmt
              begin
                z:=z^.naechster;
                z^.naechster:=z^.naechster.naechster;
                Dispose(z);
              end;
          Items.Delete(ii);
          letzter:=ii;
        end;
      if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
      ListBoxAnzeige.Selected[letzter]:=true;
      end;
  end;
end;

Vielen Dank im Voraus
jawo3

[DeddyH]

Du willst innerhalb der For-Schleife die komplette verkettete Liste bis auf die Wurzel freigeben?

[jawo3]

Eigentlich nicht:oops:

Ich muss also noch einschränken und abgleichen, ob das markierte Element dem aktuellen Zeiger entspricht?

[jawo3]

Dieser Versuch ist leider auch kläglich gescheitert:

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii: integer;
    letzter : integer;
begin
  if ListBoxAnzeige.Count<>0 then
  begin
  with ListBoxAnzeige do
      begin
        for ii := -1 + Items.Count downto 0 do
        if Selected[ii] then
        begin
          z:=Wurzel;
            while z<>nil do                               //Schleife, die Änderung in die Zeigerstruktur übernimmt
              begin
                z:=z^.naechster;
                if ListBoxAnzeige.Items[ii]=z^.Inhalt then
                begin
                  z^.naechster:=z^.naechster.naechster;
                  Dispose(z);
                end;
              end;
          Items.Delete(ii);
          letzter:=ii;
        end;
      if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
      ListBoxAnzeige.Selected[letzter]:=true;
      end;
  end;
end;

[DeddyH]

Das Hauptproblem ist hier: eine verkettete Liste ist nicht indiziert, die Items der ListBox aber schon. Du wirst also einen "internen Zähler" implementieren müssen. Dabei hat das Wurzelelement der Liste den Zählwert 0, dessen Nachfolger dann die 1 usw.
Pseudocode:

Delphi-Quellcode:

Zaehler := 0;
z := Wurzel;
while z <> nil do
  begin
    if ListBox.Items.Selected(Zaehler) then
      AusListeLöschen;
    z := z^.naechster;
    inc(Zaehler);
  end;

Das ist jetzt ungetestet, sollte im Groben aber stimmen.

[jawo3]

Ich habe gerade mal versucht, das einzufügen, aber ich erhalte immer "list index out of bounds". :?:
Irgendwie habe ich das noch nicht richtig verstanden...

Hier nochmal mein Stand:

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii, zaehler: integer;
    letzter : integer;
begin
  if ListBoxAnzeige.Count<>0 then
  begin
  with ListBoxAnzeige do
      begin
        for ii := -1 + Items.Count downto 0 do
        if Selected[ii] then
        begin
          z:=Wurzel;
          zaehler:=0;
          letzter:=0;
            while z<>nil do
              begin                               //Schleife, die Änderung in die Zeigerstruktur übernimmt
              if Selected[zaehler] then
                begin
                    z^.naechster:=z^.naechster; //.naechster
                    Dispose(z);
                end;
              z := z^.naechster;
              inc(Zaehler);
              end;
          ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
          letzter:=ii;
          end;
      if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
      ListBoxAnzeige.Selected[letzter]:=true;
      end;
  end;
end;

[DeddyH]

Du hast eine Schleife zuviel. Entweder Du gehst mit der For-Schleife die Items der Listbox durch oder mit der While-Schleife die Liste. Ich würde die 2. Möglichkeit favorisieren, wie in meinem Pseudocode gezeigt.

[jawo3]

So, ich habe die eine Schleife rausgeworfen, aber immernoch "list index out of bounds"...
Irgendwie fühle ich mich gerade ziemlich dumm:(

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii, zaehler: integer;
    letzter : integer;
begin
  if ListBoxAnzeige.Count<>0 then
  begin
    z:=Wurzel;
    zaehler:=0;
    while z<>nil do
    begin                               //Schleife, die Änderung in die Zeigerstruktur übernimmt
      if ListboxAnzeige.Selected[zaehler] then
      begin
        z^.naechster:=z^.naechster.naechster;
        Dispose(z);
      end;
      z := z^.naechster;
      inc(Zaehler);
    end;
    ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
    letzter:=ii;
    if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
    ListBoxAnzeige.Selected[letzter]:=true;
  end;
end;

[DeddyH]

Mich wundert es eher, dass Du keine AV oder InvalidPointerOperation bekommst. Du gibst ggf. den Speicher für z frei und greifst anschließend auf den Inhalt der nicht mehr existenten Referenz zu. Hast Du die Tutorials wirklich durchgeackert?

[jawo3]

Ja, ich habe alles aus dem Link von oben durchgelesen
(http://www.michael-puff.de/Programmi...s/Listen/HTML/)
insbesondere die Prozedur DeleteNextNode. Es ist mir nur die Frage aufgekommen was genau jetzt "Node.next" gemeint ist, weil das vorher noch nicht deklariert wurde.
Ich meine, das auch soweit verstanden zu haben, aber ich kann das nicht richtig umsetzen, weil mich dieses zusätzliche mit dem markierten ListBox-Element und dem Zähler verwirrt.

Es wäre super, wenn du mir genau erklären könntest, was ich machen muss. Ich habe vorher noch nie mit Listen gearbeitet und kann das normalerweise immer erst verstehen, wenn ich es vor mir habe...

Danke für deine Mühen
jawo3

[jawo3]

Auch in der dort verwendeten Form funktioniert das nicht...:(
Ich habe nochmal einen neuen Zeiger Temp_z als Zwischenschritt erstellt.

Das läuft aber immer noch nicht... Bitte hilf mir :cry:

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject);    //Button entfernt markierte Einträge aus der Liste
var ii, zaehler: integer;
    letzter : integer;
    Temp_z: Zeiger;
begin
  if ListBoxAnzeige.Count<>0 then
  begin
    z:=Wurzel;
    zaehler:=0;
    while z<>nil do
    begin                               //Schleife, die Änderung in die Zeigerstruktur übernimmt
      if ListBoxAnzeige.Selected[zaehler] then
      begin
        Temp_z:=z^.naechster;
        z^.naechster:=z^.naechster.naechster;
        Dispose(Temp_z);
      end;
      z:= z^.naechster;
      inc(Zaehler);
    end;
    ButtonAnzeigenClick(Sender);      //Neue Liste anzeigen
    letzter:=ii;
    if ListBoxAnzeige.Count<=letzter then dec(letzter);     //Eintrag an der Stelle der letzten Löschung wird markiert
    ListBoxAnzeige.Selected[letzter]:=true;
  end;
end;

[DeddyH]

Da ich zu der Überzeugung gekommen bin, dass das mit Worten schwieriger zu beschreiben ist als mit Code, ausnahmsweise (aus der hohlen Hand getippt, daher ohne Gewähr):

Delphi-Quellcode:

procedure TForm1.ButtonEntfernenClick(Sender: TObject); //Button entfernt markierte Einträge aus der Liste
var zaehler: integer;
    PCurrent,      //Zeiger auf das aktuelle Listenelement
    PPrior,        //Zeiger auf den Vorgänger von PCurrent
    PNext: Zeiger; //Zeiger auf den Nachfolger von PCurrent
begin
  PCurrent := Wurzel; //an der Wurzel anfangen
  zaehler := 0;
  PPrior := nil;      //die wurzel hat keinen Vorgänger
  while (PCurrent <> nil) and (zaehler < ListBoxAnzeige.Count) do
    begin //Schleife, die Änderung in die Zeigerstruktur übernimmt
      //zuerst Zeiger auf den Nachfolger sichern
      PNext := PCurrent^.naechster;
      //Element ist zum Löschen markiert
      if ListBoxAnzeige.Selected[zaehler] then
        begin
          //Sonderfall: Wurzelelement soll gelöscht werden
          if PCurrent = wurzel then
            begin
              //Speicher freigeben
              Dispose(PCurrent);
              //wurzel entsprechend neu setzen
              wurzel := PNext;
              //und weiter positionieren
              PCurrent := wurzel;
            end
          else
            begin
              //wenn meine Logik stimmt, ist die Abfrage unnötig, aber man weiß ja nie
              if PPrior <> nil then
                begin
                  //Nachfolger des Vorgängers auf eigenen Nachfolger umbiegen
                  PPrior^.naechster := PNext;
                  //und Speicher freigeben
                  Dispose(PCurrent);
                  //weiter positionieren
                  PCurrent := PNext;
                end;
            end;
        end
      else
        //gab nix zu löschen
        begin
          //aktuelles Element als Vorgänger merken
          PPrior := PCurrent;
          //nächstes Element zum aktuellen machen
          PCurrent := PNext;
        end;
      //Zähler inkrementieren
      inc(zaehler);
    end;
  ListBoxAnzeige.DeleteSelected;
end;

Es kann sehr gut sein, dass da noch Fehler enthalten sind, aber das wirst Du ja dann merken.

[jawo3]

Vielen, vielen Dank!

Das war alles super verständlich und funktioniert einwandfrei:!:

:thumb:
jawo3