Anfänger - wie Zahlen zum rechnen in Datei speichern ?

[Jiron]

Wie Zahlenreihen mit denen ich später noch rechnen will in eine Datei speichern ?


Hallo Zusammen

Kurze Vorgeschichte dazu:
Hab mich vor einigen Jahren mal bissel mit Torbo Pascal beschäftigt ( als die PC's noch langsam genug waren das es lief ) und hab mir nun in den Kopf gesetzt "Delphi" zu lernen. Da ich mich einwenig für Zahlenspielerreien interessiere, möchte ich mir eine Art Lottoprogramm schreiben, um so in die Bereiche Rechnen, Graphische Darstellungen und eventuell in Richtung Datenbanken zu kommen, die mich auch interessieren. Das wird zwar dauern, aber Zeit dafür hab ich.
Allerdings hab ich hier in meiner Gegend nicht die Möglichkeit das an einer Schule zu lernen noch noch im Bekanntenkreis, jemanden zum Fragen, also würde ich gern eure Hilfe in Anspruch nehmen.
Nun zu meinem Problem. Ich hab mir überlegt in welcher Art ich meine Daten am besten abspeichere. Da ich später noch damit rechnen möchte hab ich mich für ein Array entschieden, aber das klappt irgendwie nicht, könntet ihr mir einen Tip geben ?
Und ich hab zwischendurch mal die Fehlermeldung : "E/A Fehler 6" erhalten und hab trotz zwei Bücher und Hilfedateien keine Erklärung dafür gefunden. Wo kann ich beoi solchen Fehlermeldungen da nachschauen ?

Delphi-Quellcode:

var
  Form1: TForm1;
  z1 , z2 , z3 , z4 , z5, z6 , zz  : integer;


implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
close;
end;

procedure TForm1.Edit1Exit(Sender: TObject);

Var
 Nr : integer;
 zahlenreihe: String;
 MyFile : array [1..7] of integer ;

begin
  if (Edit1.Text='') or
     (Edit2.Text='') or
     (Edit3.Text='') or
     (Edit4.Text='') or
     (Edit5.Text='') or
     (Edit6.Text='') or
     (Edit7.Text='') then
      exit;

   z1 := StrToInt(Edit1.Text);
   z2 := StrToInt(Edit2.Text);
   z3 := StrToInt(Edit3.Text);
   z4 := StrToInt(Edit4.Text);
   z5 := StrToInt(Edit5.Text);
   z6 := StrToInt(Edit6.Text);
   zz := StrToInt(Edit7.Text);

   if (z1<1) or (z1>49) then exit;
   if (z2<1) or (z2>49) then exit;
   if (z3<1) or (z3>49) then exit;
   if (z4<1) or (z4>49) then exit;
   if (z5<1) or (z5>49) then exit;
   if (z6<1) or (z6>49) then exit;
   if (zz<1) or (zz>49) then exit;


   if (z1>=z2)or(z1>=z3)or(z1>=z4)or(z1>=z5)or(z1>=z6)or(z1=zz)then exit;
   if (z2>=z3)or(z2>=z4)or(z2>=z5)or(z2>=z6)or(z2=zz)then exit;
   if (z3>=z4)or(z3>=z5)or(z3>=z6)or(z3=zz)then exit;
   if (z4>=z5)or(z4>=z6)or(z4=zz)then exit;
   if (z5>=z6)or(z5=zz)then exit;
   if z6=zz then exit;

   //     Zahlenreihe eingeben, Datei anlegen, bzw. Zahlen speichern, letzte Zahlenreihe mit Nummer ausgeben
   MyFile[1] := z1 ;
   MyFile[2] := z2 ;
   MyFile[3] := z3 ;
   MyFile[4] := z4 ;
   MyFile[5] := z5 ;
   MyFile[6] := z6 ;
   MyFile[7] := zz ;

   AssignFile(MyFile,zahlenreihe);
   {$I-}
     if FileExists(zahlenreihe) then
    Reset(MyFile)
   else
    ReWrite(MyFile);
   {$I+}
     if IOResult=0 then
     begin;
       System.Seek(MyFile,SizeOf(MyFile));
       Write(MyFile,Nr);
     end;
     CloseFile(MyFile);

   Edit8.Text := IntToStr(Nr, zahlenreihe);

end;
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin
   if not (Key in [#8,#48..#57]) then
     Key := #0;
end;

end.

Ich glaub ich hab neben meiner Unkenntnis noch einige Gedankenfehler drin. Bitte euch um Hilfe.
Noch etwas dazu, ich weiss das die Bedingungen auch ziehmlich umständlich geschrieben sind, mir geht es in erster Linie um die Funktionalität damit ich es auch verstehe. Wenn es dann läuft werde ich mich um eine bessere Schreibweise kümmern. Da das ganze lernen etwas länger dauern dürfte, möchte ich eines nach dem anderen machen.
(Hoffe hab mich bei der Programmschreiberrei nicht zu doof angestellt)

Soweit mein Anliegen an euch.
Gruß Jiron

[edit=SirThornberry]Delphi-Tags gesetzt - nächstes mal bitte selbst machen Mfg, SirThornberry[/edit]

[jfheins]

Da ich mich mit den Dateifunktionen nicht so auskenne würde ich es so machen:

Delphi-Quellcode:

fs := TFileStream.Create(...);
fs.position := fs.size;
fs.writebuffer(@MyFile[0], 4*length(myfile));
fs.free;

Ansonsten ... wie gesagt ich kenne mich damit nicht aus, aber ich glaube du solltest reset, rewrite, seek und write nich tdas array übergeben sondern eine art dateizeiger ...

Btw.: Ich würde über die Variablenbenennung nochmal nachdenken

P.S.: Mit delphi-Tags [delphi]...CODE...[/delphi] sieht der Code deutlich schöner (=besser lesbar) aus

[fajac]

Delphi-Quellcode:

var
  fMyFile  : file of Integer;
  fileName : string;
begin
  fileName := ...irgendwas
  AssignFile (fMyFile, fileName);
  if FileExists (fileName) then
    begin
      Reset (fMyFile);
      Seek (fMyFile, FileSize (fMyFile));
    end
  else
    rewrite (fMyFile);
  try    
    BlockWrite (fMyFile, MyFile [1], 7);
  finally
    CloseFile (fMyFile);
  end;
end;

[himitsu]

zunächst einmal könntest du ja eventuell deine verwendete Delphi ins DP-Profil mit eintragen (oder es notfalls auch einfach mal im Thread mit erwähnen, falls es nötig wird), dann könnten wir gezielter auf's Delphi eingehen (jeder reagiert ja manchmal etwas anders und bietet vorallem andere Möglichkeiten der Programmierung)

in GetLastError sind die "System Error Codes" verlinkt
bzw IOResult > http://www.freepascal.org/docs-html/.../ioresult.html


(Windows) Fehlercode 6 wäre also "Invalid file handle"

Wo (bei welchem Befehl) tritt den der Fehler auf?



Ansonsten kommt es erstmal drauf an, um wieviele Zahlen es sich mal handeln soll, welche da verwaltet werden müssen und welche Art von Zugriff du benötigst.

Als "Textdatei" und Dergleichen kommt mehr nur ein sequenzieller Zugriff in Frage,
also alles hintereinander weg lesen oder schreiben.

Bei einer Datenbank könntest du auch sehr leicht hin und her springen, darin suchen lassen und zwischendrin war einfügen/löschen.


Die verwendeten "alten" Relikte ala AssignFile und ReadLn/WriteLn sind recht langsam,
also für große Datenmengen nicht unbedingt gut geeignet. (allerdings lassen sie sich natürlich recht einfach verwenden)

[p80286]

Hallo Jiron,

Dein Fehler liegt hier:MyFile : array [1..7] of integer ; falls das Deine Datei-Deklaration sein soll.

Was Du (wahrscheinlich) benötigst ist ein
MyFile = File of integer; oder

Delphi-Quellcode:

type
  tMyType=array[1..7] of integer;
var
  MyFile = File of tmyType;

in den Du den Inhalt Deines arrays speichern würdest.

Zitat von jfheins:

Delphi-Quellcode:

fs := TFileStream.Create(...);
fs.position := fs.size;
fs.writebuffer(@MyFile[0], 4*length(myfile));
fs.free;

Das ist die "professionelle" variante, wobei ich statt

Delphi-Quellcode:

fs.writebuffer();
   fs.write(buffer,sizeof(buffer));

bevorzuge. aber das ist Geschmackssache.
Schau Dir einmal die Hile zu TFilestream an.

Gruß
K-H

[stoxx]

Zitat:

Die verwendeten "alten" Relikte ala AssignFile und ReadLn/WriteLn sind recht langsam,

die Aussage ist eigentlich nicht ganz korrekt, das liegt nur daran, weil niemand einen Buffer verwendet.

das muss man leider selbst machen. Hab mir sagen lassen, dass der C Compiler von Empa .. ähm .. naja Borland, das schon selbst machen würde.

Delphi-Quellcode:

GetMem(FBuffer,BufferSize);
System.SetTextBuf(FFile,FBuffer^,BufferSize);
AssignFile(FFile, FileName);
closeFile(FFile);
FreeMem(FBuffer,BufferSize);

Benutze ich aber auch nicht, weil ich dann lieber gleich die objektorientierte Lösung /Kombination aus TReader TStream verwende ..


http://www.delphipraxis.net/internal...hlight=treader


ist irgendwie hübscher

[stoxx]

Zitat:

Das ist die "professionelle" variante, wobei ich statt

Delphi-Quellcode:

fs.writebuffer(); 
   fs.write(buffer,sizeof(buffer));

bevorzuge. aber das ist Geschmackssache.

das ist aber arg umständlich, schau Dir mal die Kombination mit TReader an ..

[Jiron]

Hallo und ein großes Dankeschön .
Bin doch erstaunt das sich so viele zu Helfen gemeldet haben. Das gibt mir wieder bissel Schwung. War ja doch schon bissel frustriert das ich schon am Anfang des programmierens so fest hing.
Nun möchte ich ersteinmal die Fragen beantworten.

Hallo jfheins
Danke für deinen Quellcodevorschlag. Diese Variante sieht wesentlich besser aus als meine und entspricht sicherlich auch eher der Delphiprogrammierung als mein Versuch. Ich werde mir die Sache mal genauer ansehen. Ehrlich gesagt ist meine Programmierdenken noch sehr von Torbo Pascal geprägt. Aber eine Frage hab ich noch. Wie meinst du deinen Hinweis: "Ich würde über die Variablenbenennung nochmal nachdenken". Z1 ist einfach für mich die erste Zahl einer Ziehungsreihe und und als Integer, halt weil ich nicht weiss welche Größenberechnung da mal noch kommt und ich ersteinmal unötige Typenumstellungen vermeiden möchte. Und wie gesagt, im Moment versuche ich ein Programm zu schreiben was läuft und was ich auch wenn ich es schreibe verstehe. Danach komme ich ganz sicher auf deinen Vorschlag einer sinnvolleren programmierung zurück und werd alles noch mal überarbeiten. Dein Vorschlag ist aber gespeichert , Gruß Jiron.

Hallo Fajac
Dein Vorschlag ist so ungefähr das was ich auch in Büchern gefunden hab, nur das da nicht mit "BlockWrite" gearbeitet wurde. Ich hab versucht statt File ein Array da reinzubringen um von vornherein festlegen zu können, was in der Zahlenreihe (myfile) z1 usw. ist, damit ich später auch damit rechnen kann. Wenn das so mit file auch geht, werde ich es so mal versuchen. Nur stellt sich für mich die Frage, woher weis hier das File wie sie z1 bis zz aufnehmen muß ? Ich werde es aber auf alle Fälle mal versuchen, danke dir.

Hallo himitsu
Als erstes danke für den Hinweis. Ich arbeite mit Delphi 6 und hab es auch ins Profil eingetragen.
Der Fehler trat auf als ich in meiner Version des Programmes es noch mit "File" anstatt Array versucht hab.
Was die Anzahl der Zahlen betrifft, naja, ich möchte mich an die Ziehungen der Samstagziehungen halten, also bisher ca. 3000 Ziehungen mal 8 Zahlen, (mit Reihennummer - von 0 bis...) grobgesagt. Dann kommen da natürlich alle möglichen Auswertungen dazu, da kann ich das "Ausmaß" im Moment schlecht bestimmen.
Textdateien wohl weniger, da eigendlich alles am Bildschirm ausgegeben werden soll und wenn überhaupt nur kurze Auswertungsdateien, max. 80 - 100 Zahlenreihen mal ausgedruckt werden sollen. Eine Datenbank wäre für mich schon von Interesse, aber nach dem belesen dieses Themas hab ich ordentlichen Respekt davor. Sicher verwende ich etwas "angstaubte" Befehle, hatte mir ja vorgenommen, die "Modernisierung" des Programmes dann zu machen wenn's läuft und ich auch verstehe, was ich da programmiert habe. Wenn es aber möglich ist, von Anfang an eine Datenbank mit aufzubauen, dann wäre dieses schon in meinem Sinne. Nur weiß ich garnicht wo ich da anfangen sollte. Hab 2 Delphibücher und werd dort noch mal unter Datenbank nachschlagen. Ich glaub du hast mich da schon in die richtige Richtung geschoben , Danke.

Hallo p80286
Ich danke dir für deine zwei Vorschläge. Die Lösung die ich gesucht hab ist deine zweite Variante, danke. Da du mir aber nu diese zwei Möglichkeiten aufgezeigt hast, kannst du mir vielleicht auch meine Frage daraus beantworten. Da ich mit diesen Zahlen ja später noch rechnen möchte, ist welche dieser zwei Möglichkeiten die sinnvollere? Deine letztere Möglichkeit hab ich mir notiert und werde sie mir noch genauer im Programm mal anschauen. Für ne professionelle Variante brauch ich auch erst das profisionelle Verständnis der Materie .

Hallo stoxx
Wenn ich dich richtig verstanden hab , geht die programmierung der Sache auch ohne eine Buffervariante. Nur wenn ich mal das Programm effektiver gestallten möchte sollte ich das schon mit in Betracht ziehen. Werd ich auch, danke für den Hinweis. Aber eine Frage dazu: Sollte ich von Anfang an, eine Datenbank mit aufbauen, ist dabei dieser Buffer auch noch angebracht ? Auf alle Fälle aber ein interessanter Hinweis, danke dir.

Nochmals danke an alle die hier geantwortet haben. Ich werde mir in den nächsten Tagen alles nochmal ansehen und einiges ausprobieren. Denke komme jetzt ein ganzes Stück weiter.
Gruß Jiron

[Teekeks]

Hallo!
Ich hätte das ganze so gelößt:

Delphi-Quellcode:

var
  fMyFile  : file of Integer;
  fileName : string;
begin
  fileName := ...irgendwas
  AssignFile (fMyFile, fileName);
  rewrite (fMyFile);
  try   
    Write(fMyFile,Z1);
    Write(fMyFile,Z2);
    {... für alle anderern Variablen auch...}
  finally
    CloseFile (fMyFile);
  end;
end;

Dann könntest du auch so die Variablen aus der Datei wieder auslesen:

Delphi-Quellcode:

var fMyFile : file of Integer;
begin
// Initialisieren des Files...
  Read(fMyFile,Z1);
  Read(fMyFile,Z2);
  //...
end;

oder eben wie weiter oben schon gesagt als TFilestream un fs.Write(Z1,sizeof(integer));


gruß Teekeks

[Jiron]

hallo Teekeks

Danke für deinen Hilfe.
Ich werde auch diese Möglichkeit ausprobieren. Es ist schon erstaunlich wieviele Möglichkeiten es für ein Problem gibt. Nu muß ich mal rausfinden, was für mein weiteres vorgehen das bessere ist.
meld mich wieder, nachmals danke.
Gruß Jiron