Eine lineare Liste an Strings als Datei speichern

[thejacensolo]

Hey, wie schon oben geschrieben versuche ich eine lineare Liste an Strings als Datei abzuspeichern, so dass ich sie später aufrufen kann.
Ich probiere einen Vokabel-Trainer zu programmieren, und erstelle eine Liste, in der die Vokabeln eingespeichert werden. (mit initvok) usw. Diese Liste kann auch abfragen, und löschen. Jetzt würde ich gerne noch dass speichern dazu nehmen, da es strings sind habe ich versucht es mit liste.savetofile(edit1.text + edit2.text + '.txt') zu speichern, aber dass klappt natürlich nicht. Ja ich habe dass Forum und Google durchsucht, und bin auf keine Lösung gekommen. soll ich eine Variable in meiner Unit Tliste erstellen die immer wenn eine vokabel erzeugt wird sie einspeichert? wäre dass nicht zu lang? Habt ihr da ein paar tipps?
Das ist mein bisherige Lösung:

Delphi-Quellcode:

procedure TForm1.Button12Click(Sender: TObject);
begin
  liste.SaveToFile(Edit2.text + Edit3.text + '.txt');
end;

Gruß
Tibor

Liste ist natürlich ein Objekt der klasse Tliste

[Luckie]

Was für eine Klasse liste? Und was heißt "klappt nicht"?

[thejacensolo]

liste ist ein objekt der klasse Tliste

Delphi-Quellcode:

UNIT mTListe;

interface

//--------------------  ggf Uses-Liste anpassen !  --------------------
uses  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, ComCtrls, Menus, mTVokabel;

type
  TListe = class

  public //Attribute
    Laenge : Integer;
    Erste : TVokabel;
     //Objektbeziehungen:
        // kenntTVokabel : TVokabel;

  public //Methoden
    constructor initList (E: String; D: string); virtual;
    procedure hinzufuegen (E: String; D: string); virtual;
    function abfragen (n: integer) : string; virtual;
    function Dabfragen (n: integer) : string; virtual;
    function zufallfragenE (n: integer) : string; virtual;
    function zufallfragenD (n: integer) : string; virtual;
    procedure loeschen(n: integer); virtual;
   end;

implementation

//+---------------------------------------------------------------------
//|         TListe: Methodendefinition 
//+---------------------------------------------------------------------

//-------- initList (public) -------------------------------------------
constructor TListe.initList (E: String; D: string);
var V: TVokabel;
begin
  Laenge := 1; //Liste enthaelt erstmal 1 Vokabel
  V := TVokabel.initVok(E,D); // Erzeuge mir eine Vokabel mit dem Wort Vok HIER PROBLEM
  Erste := V;
end;

//-------- hinzufuegen (public) ----------------------------------------
procedure TListe.hinzufuegen (E: String; D: string);
var aktVok, neueVok: TVokabel; i: Integer;
begin

  neueVok := TVokabel.initvok(E,D); //Erzeuge erstmal Vokabel
  // 1. Fall: Es gab bisher nur 1 Vokabel
  if Laenge = 1 then
  Erste.Naechste := neueVok
  else
  begin
    aktVok := Erste;
    for i := 1 to Laenge -1 do //Achtung
    begin
      aktVok := aktVok.Naechste // die neue Aktuelle ist die alte Naechste
    end;
    aktVok.Naechste := neueVok;
  end;
  inc(Laenge);
end;

//-------- abfragen (public) -------------------------------------------
function TListe.abfragen (n: integer) : string;
var i: integer; vokabel: Tvokabel;
begin
  Vokabel := Erste;
  //n := Random(t);
  for i:= 1 to n - 1 do
   begin
     Vokabel := vokabel.naechste;
   end;
   result := vokabel.englisch;
end;

function TListe.Dabfragen (n: integer) : string;
var i: integer; vokabel: Tvokabel;
begin
  Vokabel := Erste;
  //n := Random(t);
  for i:= 1 to n - 1 do
   begin
     Vokabel := vokabel.naechste;
   end;
   result := vokabel.Deutsch;
end;

function Tliste.zufallfragenD (n: integer) : string;
var i:integer; vokabel: Tvokabel;
  Begin
    vokabel := erste;
   for i := 1 to n - 1 do
    begin
      vokabel := vokabel.naechste;
    end;
   result := vokabel.englisch;
  end;

function Tliste.zufallfragenE (n: integer) : string;
var i:integer; vokabel : tvokabel;
  Begin
   vokabel := erste;
   for i := 1 to n - 1 do
    begin
      vokabel := vokabel.naechste;
    end;
   result := vokabel.deutsch;
  end;

procedure TListe.loeschen (n:integer);    //FEHLER
 var i:integer; vokabel,vokabel2 : tvokabel;
  Begin
   vokabel := erste;
   for i := 1 to n - 2 do
    begin                               //naechte.naechste
      vokabel := vokabel.naechste;
    end;
   vokabel2 := vokabel.naechste;
   vokabel.naechste := vokabel.naechste.naechste;
   vokabel := vokabel2;
   vokabel.destroy;
  laenge := laenge - 1;
end;
  end.

Der Fehler ist Indetifier intends no memeber "savetofile"

[DeddyH]

Stimmt ja auch, eine Methode SaveToFile konnte ich in Deiner Listenklasse nirgends entdecken.

[thejacensolo]

Aber wie kann ich sonst diese Liste (die ja eigentlich nur aus strings besteht) abspeichern?

[Aviator]

Wenn du die Liste mit

Delphi-Quellcode:

Liste.SaveToFile()

abspeichern willst, dann muss in deiner Klasse auch eine entsprechende Funktion existieren, die diese Möglichkeit anbietet. Schreib dir also in deiner Klasse eine Funktion, die die Liste speichert.

Oder leite deine Klasse von TStringList ab. Dort gibt es eine SaveToFile Methode wenn ich mich nicht täusche. Dann musst du wenn ich das richtig verstehe eigentlich gar nichts mehr machen.

[himitsu]

Zitat:

Zitat von thejacensolo (Beitrag 1235762)

Aber wie kann ich sonst diese Liste (die ja eigentlich nur aus strings besteht) abspeichern?

Indem DU eine Speicherfunktion für deine Klasse schreibst? (die darfst du auch gern SaveToFile nennen, wenn sie ihre Daten in eine Datei speichert)

Wenn es alle einzeilige Strings sind, dann kannst du dafür gern eine TStringList benutzen, wo DU die Strings erstmal reinkopierst. (TStrings.Value)

[BUG]

Zitat:

Zitat von Aviator (Beitrag 1235764)

Oder leite deine Klasse von TStringList ab. Dort gibt es eine SaveToFile Methode wenn ich mich nicht täusche. Dann musst du wenn ich das richtig verstehe eigentlich gar nichts mehr machen.

Ich vermute mal, dass das eine Schulaufgabe ist. Somit fallen die softwaretechnisch sinnvollen Lösungen (Listen nicht selbst implementieren, usw.) erst einmal weg :wink:

Es scheint ja um einen Vokabeltrainer zu gehen. Als erstes solltest du dir überlegen, wie du die Vokabeln in der Datei speichern willst.
Für eine Hausaufgabe schlage ich vor, dass du ein einfaches Format nimmst, welches du deinem Lehrer gut erklären kannst.

Zum Beispiel eine Textdatei, mit je einer Zeile für Deutsch und Englisch:

Code:

Hund
dog
Katze
cat
Programmierer
programmer
Kaffee
coffee

Im Unterricht habt ihr vermutlich gezeigt bekommen, wie man eine Zeile in eine Textdatei schreibt (writeln) und sie ausliest (readln).
Zum Speichern gehst du die Liste durch und schreibst für jeden Eintrag die nötigen zwei Zeilen.
Umgekehrt liest du zum Laden immer zwei Zeilen aus und trägst sie in die Liste ein.

[thejacensolo]

Zitat:

Zitat von BUG (Beitrag 1235766)

Zitat:

Zitat von Aviator (Beitrag 1235764)

Oder leite deine Klasse von TStringList ab. Dort gibt es eine SaveToFile Methode wenn ich mich nicht täusche. Dann musst du wenn ich das richtig verstehe eigentlich gar nichts mehr machen.

Ich vermute mal, dass das eine Schulaufgabe ist. Somit fallen die softwaretechnisch sinnvollen Lösungen (Listen nicht selbst implementieren, usw.) erst einmal weg :wink:

Es scheint ja um einen Vokabeltrainer zu gehen. Als erstes solltest du dir überlegen, wie du die Vokabeln in der Datei speichern willst.
Für eine Hausaufgabe schlage ich vor, dass du ein einfaches Format nimmst, welches du deinem Lehrer gut erklären kannst.

Zum Beispiel eine Textdatei, mit je einer Zeile für Deutsch und Englisch:

Code:

Hund
dog
Katze
cat
Programmierer
programmer
Kaffee
coffee

Im Unterricht habt ihr vermutlich gezeigt bekommen, wie man eine Zeile in eine Textdatei schreibt (writeln) und sie ausliest (readln).
Zum Speichern gehst du die Liste durch und schreibst für jeden Eintrag die nötigen zwei Zeilen.
Umgekehrt liest du zum Laden immer zwei Zeilen aus und trägst sie in die Liste ein.

Wir haben im info unterricht das Speichern von Vokabeln in der Liste, das Abfragen, und das suchen gemacht. Das mit dem speichern kam mir nur als idee, weil ich vorhwer bei einem Texteditor den wir erstellt haben dasselbe gemacht habe. als eine Textbox als .txt datei in ein belibiges verzeichnis speichern.

Zitat:

Indem DU eine Speicherfunktion für deine Klasse schreibst? (die darfst du auch gern SaveToFile nennen, wenn sie ihre Daten in eine Datei speichert)

Ich habe momentan keine Idee wie ich soetwas schreiben könnte. Meine erste überlegung war, ich könnte doch ein Object Vokabel erstellen, dass sich immer beim initiieren in ein Array einspeichert. Aber ich weiß nicht wie ich dass umsetzen könnte.

[Popov]

Also ich weiß nicht ob ich das als Klasse lösen würde, andererseits, warum nicht? Schließlich ist es eine Übung.

Ich will mir jetzt nicht die ganze Klasse antun, vor allem weiß ich nicht was in der TVokabel steht (ist das ein Klasse oder Record?). Vermutlich könnte ich es erfahren wenn ich den Code studieren würde, bin aber zu faul dazu.

Ein Ansatz den ich dir bieten könnte wäre die TStringList Klasse. Man könne es auch mit TIniFile lösen, vor allem wenn du noch weitere Bereiche hättest, aber wenn es nur eine Liste ist, geht es auch mit TStringList.

Zuerst kurz allgemein zu TStringList. Es ist eine Klasse in der man eine Liste an Strings ablegen und auch speichern kann. Vermutlich kennst du sie schon etwas, denn TMemo oder TListBox oder TStringList, alle arbeiten mit TStrings. Kennt man somit eines davon kennt man sie alle.

Uns interessiert aber nicht Add & Co, sondern die Eigenschaften Names und Values. Das funktioniert fast so wie bei der Ini:

Hund=Dog

Dabei gibt die Eigenschaft Names den Namensteil das Strings (in dem Fall Hund), Values gibt den Wertteil (in dem Fall Dog).

Die Eigenschaft Names gibt den Namensteil der X-ten Zeile zurück:

s := sl.Names[2];

Beispiel gibt den Namensteil der dritten Zeile zurück (erste Zeile beginnt bei 0). Wäre die dritte Zeile "Hund=Dog", würde das obere Beispiel "Hund" zurückgeben.

Die Eigenschaft Values gibt den Wertteil der Zeile zurück:

s := sl.Values['Hund'];

Das Beispiel gibt den Wert passend zu dem Namen. In dem Fall wäre es "Dog", da der Name "Hund" ist.

Wichtig: sollte es vorkommen, dass in der Liste der Name "Hund" mehrmals vorkommt, wird in dem Fall immer die zuerst gefundene Zeile genommen.

Also, mit Names und Values kannst du deine Vokabeln abspeichern:

Delphi-Quellcode:

var
  sl: TStringList;
begin
  sl := TStringList.Create;
  
  //Hinzufügen
  sl.Values['Hund'] := 'Dog';

  ShowMessage(sl.Values['Hund']);

Den Name Teil braucht nicht extra hinzugefügt werden. Wird mit Values ein Wert zugefügt und gibt man einen Namen ein, wie hier "Hund", wird der Name-Teil automatisch angelegt und der Wert, hier "Dog", angefügt.

Weißt du nicht welche Namen-Werte du hast, kannst du über Names drauf zugreifen:

Delphi-Quellcode:

var
  sl: TStringList;
  s: String;
  i: Integer;
begin
  sl := TStringList.Create;
  try
    //Hinzufügen
    sl.Values['Hund'] := 'Dog';

    for i := 0 to sl.Count - 1 do
    begin
      s := sl.Names[i];
      ShowMessage(sl.Values[s]);
    end;

Nun zu deiner Klasse. Du könntest ein Create zu der Klasse hinzufügen, mit einer Pfadangabe als Parameter. Das wäre dann wie bei der Ini. Im Pfad wäre dann der Pfad zu der Vokabelliste auf der Festplatte. Dann unter Create noch ein StringList Objekt anlegen und die Datei (mit der Liste) laden. Ist keine Datei zu finden, eine anlegen, ist eine da, in das TStringList-Objekt laden. Mit deinen Methoden kannst du dann Vokabeln hinzufügen und löschen, auch explizit speichern. Zusätzlich kann der Destruktor am Ende so konzipiert werden, dass er die Liste beim Beenden automatisch speichert.

[Sir Rufo]

Mal eine Frage vorweg:

Wozu hast du alle Methoden als

Delphi-Quellcode:

virtual

deklariert? :gruebel:
Als

Delphi-Quellcode:

virtual

deklariert man Methoden, wo man bei der Entwicklung schon absehen kann, dass diese Methoden wohl meistens überschrieben werden.
Als

Delphi-Quellcode:

virtual abstract

deklariert man Methoden, die überschrieben werden müssen.
Alle anderen Methoden können auch überschrieben werden, allerdings war das eigentlich nicht im Sinne des Entwicklers (was alles und nichts bedeuten muss).

Zum Thema:

Also ich würde das Speichern nicht in die Liste reinpacken (allerdings würde ich in die Liste auch nicht das Auswürfeln der Vokabeln reinpacken).

Delphi-Quellcode:

type
  // Container für die Vokabeln 
  TListe = class
  public
    procedure Clear;
    function Add( AItem : TVokabel ) : Integer;
    property Count : Integer read GetCount;
    property Items[const Index : Integer] : TVokabel read GetItem;
  end;

  // Der Vokabeltrainer (braucht aber einen Container)
  TTrainer = class
  private
    FListe : TListe;
    procedure SetListe( const Value : TListe );
  public
    procedure Reset; virtual; abstract;
    property Liste : TListe read FListe write SetListe;
  end;

  // Das Speichermodul für den Container
  TStorage = class
  private
    FFilename : string;
  protected
    procedure DoSave( AListe : TListe ); virtual; abstract;
    procedure DoLoad( AListe : TListe ); virtual; abstract;
  public
    constructor Create( const AFilename : string );

    procedure Save( AList : TListe );
    procedure Load( AList : TListe );

    property Filename : string read FFilename;
  end;

  TStorageClass = class of TStorage;

procedure TTrainer.SetListe( const Value : TListe );
begin
  if Value = FListe then
    Exit;

  FListe := Value;
  Reset;
end;

constrcutor TStorage.Create( const AFilename : string );
begin
  inherited;
  FFilename := AFilename;
end;

procedure TStorage.Save( AListe : TListe );
begin
  if not Assigned( AListe ) then
    raise Exception.Create( 'Keine Listen-Instanz übergeben!' );
  DoSave( AListe );
end;

procedure TStorage.Load( AListe : TListe );
begin
  if not Assigned( AListe ) then
    raise Exception.Create( 'Keine Listen-Instanz übergeben!' );
  DoLoad( AListe );
end;

Von der Klasse

Delphi-Quellcode:

TStorage

leitet man nun die konkreten Klassen (z.B.

Delphi-Quellcode:

TIniStorage

,

Delphi-Quellcode:

TPlainTextStorage

,

Delphi-Quellcode:

TMyBaseStorage

, ...) ab.

Um nun die Liste in eine Datei zu speichern macht man folgendes:

Delphi-Quellcode:

procedure SaveListe( AListe : TListe; const AFilename : string );
var
  LStorage : TStorage; // kein konkreter Typ!!!
  LStorageClass : TStorageClass;
begin
  case IndexText( ExtractFileExt( AFilename ), ['.txt','.ini','.xml','.db'] ) of
    0 : // PlainText-Datei
      LStorageClass := TPlainTextStorage;
    1 : // Ini-Datei
      LStorageClass := TIniStorage;
    2, 3 : // MyBase-Datei
      LStorageClass := TMyBaseStorage;
  else
    raise Exception.CreateFmt( 'Unbekannte Dateiendung "%s"', [ExtractFileExt( AFilename )] );
  end;

  // Jetzt kommt das Speichern

  LStorage := LStorageClass.Create( AFileName );
  try
    LStorage.Save( AListe );
  finally
    LStorage.Free;
  end;
end;

Am Anfang wird es wohl durchaus reichen eine einfache Storage-Klasse zu entwerfen ... aber man sollte auch verstehen, warum eine Trennung der Klassen besser ist ;)

[thejacensolo]

soll ich eine neue Klasse anstatt tliste erstellen? und was meinst du mit Container (ist dass so etwas wie speichern?). Die prozeduren Dosave und Doload, finde ich nicht in dem Quelltext, soll die in tliste drin sein? Ich deklariere immer als virtual, weil er sonst immer meckert ;).


Edit:
tschuldigung hab sie nicht gesehen, natürlich sind sie da

[Sir Rufo]

Zitat:

Zitat von thejacensolo (Beitrag 1235850)

soll ich eine neue Klasse anstatt tliste erstellen? und was meinst du mit Container (ist dass so etwas wie speichern?).

Nein, deine

Delphi-Quellcode:

TListe

ist ja ein Container (zu deutsch Behälter) worin sich die Daten (hier Vokabeln) befinden.

Zitat:

Zitat von thejacensolo (Beitrag 1235850)

Die prozeduren Dosave und Doload, finde ich nicht in dem Quelltext, soll die in tliste drin sein?

Nein, du erstellst dir eine Klasse wie folgt:

Delphi-Quellcode:

unit mTStorage;

interface

uses
  mTListe, mTVokabel;

type
  TStorage = class
  private
    FFilename : string;
  protected
    procedure DoSave( AListe : TListe );
    procedure DoLoad( AListe : TListe );
  public
    constructor Create( const AFilename : string );

    property Filename : string read FFilename;

    procedure Save( AListe : TListe );
    procedure Load( AListe : TListe );
  end;

implementation

constructor TStorage.Create( const AFilename : string );
begin
  inherited Create;
  FFilename := AFilename;
end;

procedure TStorage.Save( AListe : TListe );
begin
  // Vorher evtl. eine Abfrage ob die Liste existiert?
  // if Assigned( AListe ) then
  DoSave( AListe );
end;

procedure TStorage.Load( AListe : TListe );
begin
  // Vorher evtl. eine Abfrage ob die Liste existiert?
  // if Assigned( AListe ) then
  DoLoad( AListe );
end;

procedure TStorage.DoSave( AListe : TListe );
begin
  // Hier kreativ werden
end;

procedure TStorage.DoLoad( AListe : TListe );
begin
  // Hier auch kreativ werden
end;

end.

Zitat:

Zitat von thejacensolo (Beitrag 1235850)

Ich deklariere immer als virtual, weil er sonst immer meckert ;).

Ok ... ist aber sehr seltsam ...

[Popov]

@thejacensolo

Wahrscheinlich hast du es schon erwähnt, oder es steht im Quelltext, aber ich finde es nicht. Ich hab es zwar schon gefragt, aber keine Antwort bekommen. Wie und wo speicherst du deine Vokabeln?

Ich sehe da zwar eine TVokabel und eine Unit mTVokabel, weiß aber nicht absolut wie du das ablegst. Die Zeile

Delphi-Quellcode:

V := TVokabel.initVok(E,D);

sieht... nun ja, ich weiß nicht wie ich das deuten soll. Erstellst du das Objekt separat? Record ist es nicht, da E und D Strings sind. Sieht nach INI aus. Ini in einer Klasse?

Die Frage wie du deine Daten speichern sollst ist genauso zu beantworten wie die Frage was du in das Auto deines Vaters tanken sollst. Woher soll man das wissen, keiner kennt die Marke. Was du veröffentlicht hast ist die Klasse in der die Daten verarbeitet werden, aber den den wichtigeren Teil hast du weggelassen. Wo legst du die Daten ab. Denn so wie es aussieht ist dafür die mTVokabel Unit gedacht.

Es ist zwar nett von Sir Rufo Beispiele geliefert zu haben, aber er scheint sich auch alle Möglichkeiten offen zu halten

Delphi-Quellcode:

['.txt','.ini','.xml','.db']

.

Ich halte die Idee mit TStringList oder alternativ TIniFile am einfachsten, weil die schon die Verwaltung mit sich bringen, aber man kann auch alles alleine machen. Dann sollte man aber zweigen was man macht :-D

[thejacensolo]

Hier die Unit mtvokabel:

Delphi-Quellcode:

UNIT mTVokabel;

interface

//--------------------  ggf Uses-Liste anpassen !  --------------------
uses  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, ComCtrls, Menus;

type
  TVokabel = class

  public //Attribute
    Deutsch : string;
    Englisch : String;
    naechste : TVokabel;
    speicher : array of string;

     //Objektbeziehungen:

  public //Methoden
    constructor initVok (D: String; E: string); virtual;
    procedure SetzeEnglisch (pEnglisch: String); virtual;
    function GibEnglisch : String; virtual;

   end;

implementation

//+---------------------------------------------------------------------
//|         TVokabel: Methodendefinition 
//+---------------------------------------------------------------------

//-------- initVok (public) --------------------------------------------
constructor TVokabel.initVok (D: String; E: string);
begin
  Englisch := E;
  Naechste := nil; // Nil ist der Nullwert, dh ist noch nicht belegt.
  Deutsch  := D;
end;

//-------- SetzeEnglisch (public) --------------------------------------
procedure TVokabel.SetzeEnglisch (pEnglisch: String);
begin
  Englisch := pEnglisch
end;

//-------- GibEnglisch (public) ----------------------------------------
function TVokabel.GibEnglisch : String;
begin
  result := Englisch
end;

end.

und meine HAuptunit

Delphi-Quellcode:

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, ComCtrls, Menus, mtListe, mTvokabel;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button10: TButton;
    Button11: TButton;
    Button12: TButton;
    Button2: TButton;
    Button3: TButton;
    Button4: TButton;
    Button5: TButton;
    Button6: TButton;
    Button7: TButton;
    Button8: TButton;
    Button9: TButton;
    Edenglisch: TEdit;
    EDeutsch: TEdit;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    procedure Button10Click(Sender: TObject);
    procedure Button11Click(Sender: TObject);
    procedure Button12Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure Button5Click(Sender: TObject);
    procedure Button6Click(Sender: TObject);
    procedure Button7Click(Sender: TObject);
    procedure Button8Click(Sender: TObject);
    procedure Button9Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
t:integer; Liste:TListe; vokabel:TVokabel; Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button3Click(Sender: TObject);
begin
  Liste.hinzufuegen(Edeutsch.text, Edenglisch.text);
  showmessage('Vokabel gespeichert');
  Edeutsch.Text := '';
  Edenglisch.Text := '';
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
liste.loeschen(strtoint(Edit1.text));
showmessage('vokabel gelöscht');
end;
procedure TForm1.Button1Click(Sender: TObject);
begin

end;

procedure TForm1.Button10Click(Sender: TObject);
var n,t : integer;
begin
  n := liste.laenge;
  t := random(n);
  Edenglisch.text := Liste.zufallfragenE(t);
end;

procedure TForm1.Button11Click(Sender: TObject);
var n,t : integer;
begin
  n := liste.laenge;
  t := random(n);
  Edeutsch.text := Liste.zufallfragenD(t);
end;

procedure TForm1.Button12Click(Sender: TObject);
begin
  //liste.SaveToFile(Edit2.text + Edit3.text + '.txt');
end;

procedure TForm1.Button5Click(Sender: TObject);
var n: string;
begin
 n := inttostr(liste.laenge);
 if Edit1.Text = ''  then
  begin
    showmessage('Keine Eingabe');
  end else;
  if Edit1.Text > n then
   begin
   showmessage('zu hohe zahl');
   end
 else begin;
    Edenglisch.Text := Liste.abfragen(strtoint(Edit1.Text));
  end;
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
 if Edeutsch.text = '' then
  begin
  showmessage('Machen sie erst eine Eingabe');
  end
 else
  begin
  if EDeutsch.text = vokabel.Deutsch then
  begin
    showmessage('Die Vokabel war Richtig');
    Edenglisch.text := '';
    EDeutsch.Text := '';
  end else
  begin
    showmessage('Das war leider Falsch :-( versuche es nochmal');
    end;
  end;
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
  //Erstes speichern
  liste := Tliste.initlist(Edenglisch.Text,EDeutsch.Text);
  //vokabel := TVokabel.initvok(Edenglisch.Text, EDeutsch.text);
  showmessage('Die Vokabel wurde gespeichert');

end;

procedure TForm1.Button8Click(Sender: TObject);
begin
 if Edeutsch.text = '' then
  begin
  showmessage('Machen sie erst eine Eingabe');
  end
 else
  begin
  if EDenglisch.text = vokabel.Englisch then
  begin
    showmessage('Die Vokabel war Richtig');
    Edenglisch.text := '';
    EDeutsch.Text := '';
  end else
  begin
    showmessage('Das war leider Falsch :-( versuche es nochmal');
    end;
  end;
end;

procedure TForm1.Button9Click(Sender: TObject);
var n: string;
begin
  n := inttostr(liste.laenge);
  if Edit1.Text > n then
   begin
   showmessage('zu hohe zahl');
   end
 else
    Edeutsch.Text := Liste.dabfragen(strtoint(Edit1.Text));
  end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  //t := 0;
  //liste := Tliste.initlist(Edenglisch.Text,EDeutsch.Text);
  Randomize;
end;

end.

Ich speichere alles in der Unit Tliste ab
(initlist, hinzufuegen)

[Popov]

Ok, damit kann man schon was anfangen. Muss jetzt aber kurz weg, wenn ich wieder online bin, gucke ich mir das genauer an.

Das Problem scheint zu sein, dass du noch gar nicht die Vokabeln abspeicherst. Damit meine ich nicht Festplatte, sondern den Array.

Delphi-Quellcode:

speicher : array of string;

ist zwar da, scheint aber noch nicht genutzt zu werden.

Kriegen wir aber hin.

[thejacensolo]

Ich habe array of string eingebaut, als meinen ersten Versuch. Aber als ich vokabel2 eingebaut habe die immer den wert vokabel einnimmt und als string zu speicher gehört, hat es nicht geklappt. Speicher wird sonst nicht benutzt.

Aber danke für die Hilfe ihr seid klasse ;-)

[Sir Rufo]

@Popov

Die Klasse

Delphi-Quellcode:

TStorage

ist doch nur dafür da, das Geraffel, was du mit der

Delphi-Quellcode:

TStringList

oder

Delphi-Quellcode:

TIniFile

schreiben möchtest in eine Klasse gepackt wird und gut.

Der Code ist der gleiche ... nur wesentlich mehr OOP ;)

[Popov]

@Sir Rufo

Ich sag doch nichts. Habe ich Kritik geübt? Würde ich niemals wagen ;) Mich hat zwar XML und DB etwas verblüfft (wenn schon, denn schon), aber warum nicht? Was du da als Beispiel abgeliefert hast sieht sehr gut aus, hat Hand und Fuß, ist professionell. Gutes Beispiel.

Ob thejacensolo nun mit TStringList oder TIniFile oder Record oder Datenbanken arbeitet, bleibt ihm überlassen. Ich hab seine Frage nur so verstanden, dass er einen Ansatz, eine Idee sucht.

[Popov]

@thejacensolo

Was du bisher hast ist noch nicht viel. Bisher hast du nur

Delphi-Quellcode:

speicher : array of string;

ein Array, greifst aber noch nicht drauf zu. So wie man das verstehen könne ist, dass du die Vokabeln in dem Aray speichern möchtest. Noch machst du es noch nicht, wirst es vermutlich.

Trotzdem, bisher ist noch alles offen. Nun die Frage: willst du es tatsächlich mit dem Array machen? Nichts gegen Array, dann mußt du dich aber auch um alles kümmern, also die Verwaltung, das Speichern, das Laden, usw. Das ist eine Aufgabe für sich. Nicht sehr schwer, aber etwas Programmierarbeit.

Die andere Möglichkeit ist Vorhandenes zu nutzen. Ob das nun etwas mit TStringList oder TIniFile ist, diese Klassen bieten schon eine Verwaltung an. Du mußt dich nicht mehr um das Speichern kümmern, du speicherst deine Liste einfach mit einer Zeile Code. Bei Array wird es etwas mehr Code sein.

Also für was entscheidest du dich?

[Sir Rufo]

@Popov

Das Array ist nur ein Überbleibsel (Artefakt). Die Vokabeln werden doch über die Klasse

Delphi-Quellcode:

TListe

verwaltet.

Somit muss nur noch die Listen-Instanz gespeichert bzw. geladen werden :)

[Popov]

@Sir Rufo

Da mußt du mir weiter helfen. Vielleicht sehe ich nur nicht vor lauter Bäume den Wald nicht mehr, aber ich weiß nicht so richtig was du meinst.

In TListe gibt es einige Methoden. Guckt man sich die oberflächlich an, wie ich es anscheinend gemacht habe, entdeckt man dort die Klasse TVokabel. Auf die wird verschiedenartig zugegriffen. Ich kann mich auch täuschen, aber hier wird meiner Meinung nach die Klasse als Record genutzt. Berichtige mich wenn ich mich verguckt habe. Beispiel TListe.hinzufuegen. Mit TVokabel.initvok wird ein neueVok Objekt erstellt. Mit Erste.Naechste := neueVok wird wohl die Adresse übergeben. So langsam verliere ich da aber schon den Überblick.

[thejacensolo]

Zitat:

Zitat von Popov (Beitrag 1235925)

@thejacensolo

Was du bisher hast ist noch nicht viel. Bisher hast du nur

Delphi-Quellcode:

speicher : array of string;

ein Array, greifst aber noch nicht drauf zu. So wie man das verstehen könne ist, dass du die Vokabeln in dem Aray speichern möchtest. Noch machst du es noch nicht, wirst es vermutlich.

Trotzdem, bisher ist noch alles offen. Nun die Frage: willst du es tatsächlich mit dem Array machen? Nichts gegen Array, dann mußt du dich aber auch um alles kümmern, also die Verwaltung, das Speichern, das Laden, usw. Das ist eine Aufgabe für sich. Nicht sehr schwer, aber etwas Programmierarbeit.

Die andere Möglichkeit ist Vorhandenes zu nutzen. Ob das nun etwas mit TStringList oder TIniFile ist, diese Klassen bieten schon eine Verwaltung an. Du mußt dich nicht mehr um das Speichern kümmern, du speicherst deine Liste einfach mit einer Zeile Code. Bei Array wird es etwas mehr Code sein.

Also für was entscheidest du dich?

Dann für die Methode mit stringlist usw.

[Blup]

Eine seperate Klasse TStorage zum Speichern läuft letztendlich auf ein Visitor-Pattern hinaus.
Damit scheint aber der TE noch leicht überfordert zu sein.
Deshalb erst mal ein einfacher Lösungsansatz, der zwar nicht so universell aber dafür einfacher zu verstehen ist.

Wie speichert man eine Liste von Elementen in einer Datei?
Es gibt verschiedene Dateiformate die sich je nach Anwendungsfall unterschiedlich gut eignen.
Eine einfache Variante ist die CSV-Datei, dabei wird für jedes Element eine Zeile gespeichert. Jede Zeile wird mit Zeilenabschluss beendet (z.B. CRLF).
Innerhalb der Zeile sind die einzelnen Eigenschaften z.B. durch Komma getrennt.

Delphi-Quellcode:

TVokabel = class
  {...}
public
  function ObjectToCSV: string;
  procedure ObjectFromCSV(const AValue: string);
end;

TListe = class
  {...}
public
  procedure Clear;
  procedure SaveToStream(AStream: TStream);
  procedure ReadFromStream(AStream: TStream);
end;

function GetNextString(var AValue: string; const ASeperator): string;
var
  i, n: Integer;
begin
  n := Length(ASeperator);
  i := Pos(ASeperator, AValue);
  if i > 0 then
  begin
    Result := Copy(AValue, 1, i - 1);
    AValue := Copy(AValue, i + n, Length(AValue) - i - n + 1);
  end
  else
  begin
    Result := AValue;
    AValue := '';
  end;
end;

function TVokabel.ObjectToCSV: string; 
begin
  Result := Deutsch + ',' + Englisch;
end;

procedure TVokabel.ObjectFromCSV(const AValue: string);
var
  s: string;
begin
  s := AValue;
  Deutsch  := GetNextString(s, ',');
  Englisch := GetNextString(s, ',');
end;


procedure TListe.SaveToStream(AStream: TStream);
var
  vokabel: TVokabel;
  s: string;
begin
  vokabel := Erste;
  if Assigned(vokabel) then
  begin
    repeat
      s := vokabel.ObjectToCSV + #13#10;
      AStream.WriteBuffer(PChar(s)^, Length(s));
 
      vokabel := vokabel.naechste;
    until (vokabel = Erste);
  end; 
end;

procedure TListe.ReadFromStream(AStream: TStream);
var
  sBuffer, s: string;
  vokabel: TVokabel;
begin
  Clear;
  SetLength(sBuffer, AStream.Length);
  AStream.ReadBuffer(PChar(sBuffer)^, Length(sBuffer));
  while Length(sBuffer) > 0 do
  begin
    s := GetNextString(sBuffer, #13#10);
    if Length(s) > 0 then
    begin
      vokabel := TVokabel.Create;
      vokabel.ObjectFromCSV(s);
      hinzufuegen(vokabel);
    end;
  end;
end;

stream := TFileSream.Create('MyFile.csv', fmCreate);
MyListe.SaveToStream(stream);
stream.Free;

stream := TFileSream.Create('MyFile.csv', fmRead);
MyListe.ReadFromStream(stream);
stream.Free;

Ich habe hier bewusst auf den Einsatz einer TStringList verzichtet. Wenn der TE diese Klasse und deren Möglichkeiten nicht kennt, sollte er das Probleme zuerst mit den bekannten Mitteln lösen.

[Popov]

Die Ansätze von SirRufo und Blup finde ich zwar persönlich sehr gut und gelungen, und es ist erfreulich, dass der TE die Aufgabe mit einer Klasse löst (auch wenn es noch Probleme gibt, die Richtung stimmt zumindest), aber ich glaube zu erkennen (ich kann mich aber auch irren), dass sich der TE etwas verloren hat. Vor allem als Anfänger kann es problematisch sein am Anfang gleich zwei Hürden zu meistern. Die eine Hürde ist die Klasse. Ich finde man sollte sich erst einer Aufgabe widmen, bis die sitzt. Andere Probleme lenken davon ab, wie z. B. die Hürde beliebige Daten zu speichern. Deshalb meine Idee mit TStringList. Das kennt fast jeder, denn das ist einer der ersten Klassen die man sich genauer anguckt.

@thejacensolo

Ich hab gerade ein Beispiel geprogt. Betrachte das nicht als fertige Klasse, auch wenn sie funktioniert. Auf Sicherheitsabfrage, Fehlermeldungen usw. habe ich verzichtet, denn es ist deine Klasse. Ich hab nur ein Beispiel gemacht in dem ich verführe wie einfach diese Aufgabe mit TStringList gelöst werden kann. Den Rest mußt du alleine machten.

Delphi-Quellcode:

unit uListe;

interface

uses
  SysUtils, Classes;

type
  TVokabel2 = class
  private
    FFileName: string;
    FZeiger: Integer;
    FVokabelListe: TStringList;
    function GibZeigerVokabelDe(Zeiger: Integer): string;
  public
    constructor Create(const FileName: string);
    destructor Destroy; override;
    procedure VokabelNeu(Deutsch, Englisch: string);
    procedure VokabelBearbeiten(Deutsch, Englisch: string);
    function GibVokabelEng(VokabelDe: string): string;
    function GibVokabelDe(VokabelEng: string): string;
    function VokabelAnzahl: Integer;
    property VokabelZeiger: Integer read FZeiger;
    procedure AllesSpeichern;
    function GibErsteVokabelDe: string;
    function GibNaechsteVokabelDe: string;
    function GibVorherigeVokabelDe: string;
    function GibLetzteVokabelDe: string;
    function GibVokabelDeIndex(VokabelDe: string): Integer;
    procedure LoescheVokabel(Index: Integer);
   end;

implementation

constructor TVokabel2.Create(const FileName: string);
begin
  inherited Create;
  FFileName := FileName;
  FZeiger := 0;

  FVokabelListe := TStringList.Create;
  if FileExists(FFileName) then
    FVokabelListe.LoadFromFile(FFileName);
end;

destructor TVokabel2.Destroy;
begin
  AllesSpeichern;
  FVokabelListe.Free;
  inherited Destroy;
end;

procedure TVokabel2.VokabelNeu(Deutsch, Englisch: string);
begin
  FVokabelListe.Values[Deutsch] := Englisch;
end;

procedure TVokabel2.VokabelBearbeiten(Deutsch, Englisch: string);
begin
  VokabelNeu(Deutsch, Englisch);
end;

function TVokabel2.GibVokabelEng(VokabelDe: string): string;
begin
  Result := FVokabelListe.Values[VokabelDe];
end;

function TVokabel2.GibVokabelDe(VokabelEng: string): string;
var
  i: Integer;
begin
  Result := '';

  for i := 0 to FVokabelListe.Count - 1 do
    if SameText(VokabelEng, FVokabelListe.ValueFromIndex[i]) then
    begin
      Result := FVokabelListe.Names[i];
      Exit;
    end;
end;

function TVokabel2.VokabelAnzahl: Integer;
begin
  Result := FVokabelListe.Count;
end;

procedure TVokabel2.AllesSpeichern;
begin
  FVokabelListe.SaveToFile(FFileName);
end;

function TVokabel2.GibZeigerVokabelDe(Zeiger: Integer): string;
begin
  Result := '';

  //sind Vokablen vorhenden?
  if FVokabelListe.Count = 0 then
    Exit;

  //beim Unterschreiten der unteren Grenze, weiter mit der höhsten Vokabel
  if Zeiger < 0 then
    Zeiger := FVokabelListe.Count - 1;

  //beim Unterschreiten der oberen Grenze, weiter mit der niedrigesten Vokabel
  if Zeiger > (FVokabelListe.Count - 1) then
    Zeiger := 0;

  FZeiger := Zeiger;
  Result := FVokabelListe.Names[FZeiger];
end;

function TVokabel2.GibErsteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(0);
end;

function TVokabel2.GibNaechsteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FZeiger + 1);
end;

function TVokabel2.GibVorherigeVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FZeiger - 1);
end;

function TVokabel2.GibLetzteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FVokabelListe.Count - 1);
end;

function TVokabel2.GibVokabelDeIndex(VokabelDe: string): Integer;
begin
  Result := FVokabelListe.IndexOfName(VokabelDe);
end;

procedure TVokabel2.LoescheVokabel(Index: Integer);
begin
  FVokabelListe.Delete(Index);
end;

end.

Kurz zu der Beschreibung: über Create wird ein Pfad angegeben und somit eine Textdatei mit Vokalen geladen. Beim Freigeben wird automatisch gespeichert. Man kann aber auch mit AllesSpeichern selbst speichern. Über VokabelNeu wird eine Vokabel angelegt. Über Parameter gibt man das deutsche und englische Wort. Über GibVokabelEng und GibVokabelDe kann man eine Vokabel abfragen. Mit GibErsteVokabelDe, GibNaechsteVokabelDe, usw. kann man sich rauf und runter deutsche Vokabeln geben lassen. Die Englische mit der Methode oben abgefragt.


Hier noch ein Beispiel zum Testen:

Delphi-Quellcode:

uses
  uListe;

var
  VokabelListe: TVokabel2;

procedure TForm1.FormCreate(Sender: TObject);
begin
  VokabelListe := TVokabel2.Create(ChangeFileExt(ParamStr(0), '.txt'));
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  //Liste wird automatisch gesichert
  VokabelListe.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  VokabelListe.VokabelNeu('Hund', 'dog');
  VokabelListe.VokabelNeu('Katze', 'cat');
  VokabelListe.VokabelNeu('Programmierer', 'programmer');
  VokabelListe.VokabelNeu('Kaffee', 'coffee');
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibErsteVokabelDe);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibNaechsteVokabelDe);
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVorherigeVokabelDe);
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibLetzteVokabelDe);
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVokabelEng('katze'));
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVokabelDe('Coffee'));
end;

procedure TForm1.Button8Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.VokabelZeiger));
end;

procedure TForm1.Button9Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.VokabelAnzahl));
end;

procedure TForm1.Button10Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.GibVokabelDeIndex('Katze')));
end;

procedure TForm1.Button11Click(Sender: TObject);
var
  k: Integer;
begin
  k := VokabelListe.GibVokabelDeIndex('Katze');
  VokabelListe.LoescheVokabel(k);
end;

[thejacensolo]

Zitat:

Zitat von Popov (Beitrag 1236110)

Die Ansätze von SirRufo und Blup finde ich zwar persönlich sehr gut und gelungen, und es ist erfreulich, dass der TE die Aufgabe mit einer Klasse löst (auch wenn es noch Probleme gibt, die Richtung stimmt zumindest), aber ich glaube zu erkennen (ich kann mich aber auch irren), dass sich der TE etwas verloren hat. Vor allem als Anfänger kann es problematisch sein am Anfang gleich zwei Hürden zu meistern. Die eine Hürde ist die Klasse. Ich finde man sollte sich erst einer Aufgabe widmen, bis die sitzt. Andere Probleme lenken davon ab, wie z. B. die Hürde beliebige Daten zu speichern. Deshalb meine Idee mit TStringList. Das kennt fast jeder, denn das ist einer der ersten Klassen die man sich genauer anguckt.

@thejacensolo

Ich hab gerade ein Beispiel geprogt. Betrachte das nicht als fertige Klasse, auch wenn sie funktioniert. Auf Sicherheitsabfrage, Fehlermeldungen usw. habe ich verzichtet, denn es ist deine Klasse. Ich hab nur ein Beispiel gemacht in dem ich verführe wie einfach diese Aufgabe mit TStringList gelöst werden kann. Den Rest mußt du alleine machten.

Delphi-Quellcode:

unit uListe;

interface

uses
  SysUtils, Classes;

type
  TVokabel2 = class
  private
    FFileName: string;
    FZeiger: Integer;
    FVokabelListe: TStringList;
    function GibZeigerVokabelDe(Zeiger: Integer): string;
  public
    constructor Create(const FileName: string);
    destructor Destroy; override;
    procedure VokabelNeu(Deutsch, Englisch: string);
    procedure VokabelBearbeiten(Deutsch, Englisch: string);
    function GibVokabelEng(VokabelDe: string): string;
    function GibVokabelDe(VokabelEng: string): string;
    function VokabelAnzahl: Integer;
    property VokabelZeiger: Integer read FZeiger;
    procedure AllesSpeichern;
    function GibErsteVokabelDe: string;
    function GibNaechsteVokabelDe: string;
    function GibVorherigeVokabelDe: string;
    function GibLetzteVokabelDe: string;
    function GibVokabelDeIndex(VokabelDe: string): Integer;
    procedure LoescheVokabel(Index: Integer);
   end;

implementation

constructor TVokabel2.Create(const FileName: string);
begin
  inherited Create;
  FFileName := FileName;
  FZeiger := 0;

  FVokabelListe := TStringList.Create;
  if FileExists(FFileName) then
    FVokabelListe.LoadFromFile(FFileName);
end;

destructor TVokabel2.Destroy;
begin
  AllesSpeichern;
  FVokabelListe.Free;
  inherited Destroy;
end;

procedure TVokabel2.VokabelNeu(Deutsch, Englisch: string);
begin
  FVokabelListe.Values[Deutsch] := Englisch;
end;

procedure TVokabel2.VokabelBearbeiten(Deutsch, Englisch: string);
begin
  VokabelNeu(Deutsch, Englisch);
end;

function TVokabel2.GibVokabelEng(VokabelDe: string): string;
begin
  Result := FVokabelListe.Values[VokabelDe];
end;

function TVokabel2.GibVokabelDe(VokabelEng: string): string;
var
  i: Integer;
begin
  Result := '';

  for i := 0 to FVokabelListe.Count - 1 do
    if SameText(VokabelEng, FVokabelListe.ValueFromIndex[i]) then
    begin
      Result := FVokabelListe.Names[i];
      Exit;
    end;
end;

function TVokabel2.VokabelAnzahl: Integer;
begin
  Result := FVokabelListe.Count;
end;

procedure TVokabel2.AllesSpeichern;
begin
  FVokabelListe.SaveToFile(FFileName);
end;

function TVokabel2.GibZeigerVokabelDe(Zeiger: Integer): string;
begin
  Result := '';

  //sind Vokablen vorhenden?
  if FVokabelListe.Count = 0 then
    Exit;

  //beim Unterschreiten der unteren Grenze, weiter mit der höhsten Vokabel
  if Zeiger < 0 then
    Zeiger := FVokabelListe.Count - 1;

  //beim Unterschreiten der oberen Grenze, weiter mit der niedrigesten Vokabel
  if Zeiger > (FVokabelListe.Count - 1) then
    Zeiger := 0;

  FZeiger := Zeiger;
  Result := FVokabelListe.Names[FZeiger];
end;

function TVokabel2.GibErsteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(0);
end;

function TVokabel2.GibNaechsteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FZeiger + 1);
end;

function TVokabel2.GibVorherigeVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FZeiger - 1);
end;

function TVokabel2.GibLetzteVokabelDe: string;
begin
  Result := GibZeigerVokabelDe(FVokabelListe.Count - 1);
end;

function TVokabel2.GibVokabelDeIndex(VokabelDe: string): Integer;
begin
  Result := FVokabelListe.IndexOfName(VokabelDe);
end;

procedure TVokabel2.LoescheVokabel(Index: Integer);
begin
  FVokabelListe.Delete(Index);
end;

end.

Kurz zu der Beschreibung: über Create wird ein Pfad angegeben und somit eine Textdatei mit Vokalen geladen. Beim Freigeben wird automatisch gespeichert. Man kann aber auch mit AllesSpeichern selbst speichern. Über VokabelNeu wird eine Vokabel angelegt. Über Parameter gibt man das deutsche und englische Wort. Über GibVokabelEng und GibVokabelDe kann man eine Vokabel abfragen. Mit GibErsteVokabelDe, GibNaechsteVokabelDe, usw. kann man sich rauf und runter deutsche Vokabeln geben lassen. Die Englische mit der Methode oben abgefragt.


Hier noch ein Beispiel zum Testen:

Delphi-Quellcode:

uses
  uListe;

var
  VokabelListe: TVokabel2;

procedure TForm1.FormCreate(Sender: TObject);
begin
  VokabelListe := TVokabel2.Create(ChangeFileExt(ParamStr(0), '.txt'));
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  //Liste wird automatisch gesichert
  VokabelListe.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  VokabelListe.VokabelNeu('Hund', 'dog');
  VokabelListe.VokabelNeu('Katze', 'cat');
  VokabelListe.VokabelNeu('Programmierer', 'programmer');
  VokabelListe.VokabelNeu('Kaffee', 'coffee');
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibErsteVokabelDe);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibNaechsteVokabelDe);
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVorherigeVokabelDe);
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibLetzteVokabelDe);
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVokabelEng('katze'));
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
  ShowMessage(VokabelListe.GibVokabelDe('Coffee'));
end;

procedure TForm1.Button8Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.VokabelZeiger));
end;

procedure TForm1.Button9Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.VokabelAnzahl));
end;

procedure TForm1.Button10Click(Sender: TObject);
begin
  ShowMessage(IntToStr(VokabelListe.GibVokabelDeIndex('Katze')));
end;

procedure TForm1.Button11Click(Sender: TObject);
var
  k: Integer;
begin
  k := VokabelListe.GibVokabelDeIndex('Katze');
  VokabelListe.LoescheVokabel(k);
end;

Danke das hat mir sehr geholfen ;-) ich weiß aber gar nicht, was valuefromindex bedeutet, oder wer oder was index ist. eine Tvokabel? eine liste? eine Methode?

[p80286]

Dann schau mal in die OH zu TStrings.
ValueFromIndex gibt von

Zitat:

Hund=dog

dog zurück und index ist die "Zeilennumber" der Listeneinträge.
Der kleinste Index ist 0 der größte

Delphi-Quellcode:

Liste.count-1

Gruß
K-H