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:

Delphi-Quellcode:

MyFile : array [1..7] of integer ;

falls das Deine Datei-Deklaration sein soll.

Was Du (wahrscheinlich) benötigst ist ein

Delphi-Quellcode:

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:

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

[himitsu]

Zitat:

Zitat von Jiron

Es ist schon erstaunlich wieviele Möglichkeiten es für ein Problem gibt.

ich sag nur http://www.delphipraxis.net/internal...t.php?t=145265



Also wenn du eh alles während der Laufzeit im Arbeitsspeicher in dem Array hast, dann brauchst du es ja nur am Anfang einmal zu laden und am Ende komplett zu speichern

Delphi-Quellcode:

var X: TIntegerDynArray{Array of Integer};
  MyFile: File;

// speichern
AssignFile(MyFile, ...);
{$I-}
ReWrite(MyFile);
{$I+} 
if IOResult=0 then
begin;
  if X <> nil then BlockWrite(MyFile, @X[0], Length(X) * SizeOf(Integer));
  CloseFile(MyFile); 
end;

// speichern
AssignFile(MyFile, ...);
{$I-}
Reset(MyFile);
{$I+} 
if IOResult=0 then
begin;
  SetLength(X, FileSize(MyFile) div SizeOf(Integer));
  if X <> nil then BlockRead(MyFile, @X[0], Length(X) * SizeOf(Integer));
  CloseFile(MyFile); 
end;

Delphi-Quellcode:

var X: TIntegerDynArray{Array of Integer};
  FS: TFileStream;

// speichern
FS := TFileStream.Create()
{$I-}
ReWrite(MyFile);
{$I+} 
if IOResult=0 then
begin;
  if X <> nil then BlockWrite(MyFile, @X[0], Length(X) * SizeOf(Integer));
  CloseFile(MyFile); 
end;

// speichern
AssignFile(MyFile, ...);
{$I-}
Reset(MyFile);
{$I+} 
if IOResult=0 then
begin;
  SetLength(X, FileSize(MyFile) div SizeOf(Integer));
  if X <> nil then BlockRead(MyFile, @X[0], Length(X) * SizeOf(Integer));
  CloseFile(MyFile); 
end;

Und das Ganze nochmals per FileStream (wurde oben auch schonmal genannt)

Delphi-Quellcode:

//speichern
FS := TFileStream.Create(...);
if X <> nil then FS.WriteBuffer(@X[0], Length(X) * SizeOf(Integer));
FS.Free;

// lesen
FS := TFileStream.Create(...);
SetLength(X, FS.Size div SizeOf(Integer));
if X <> nil then FS.Readbuffer(@X[0], Length(X) * SizeOf(Integer));
FS.Free;

PS: das if X <> nil then entspricht if Length(X) > 0 then, also es ist dir überlassen, was du nutzt und wenn das Array beim Laden und Speichern nie leer ist, dann kannst du diese Abfrage auch weglassen.
Aber es gibt halt Probleme (einen nette Exception) bei einem leeren Array, wenn man dort per @X[0] auf ein nicht existierenses Element zugreifen möchte.

[isilive]

Zitat:

Zitat von himitsu

ich sag nur http://www.delphipraxis.net/internal...t.php?t=145265

OT: Das war SOOOO genial!!! :mrgreen:

[p80286]

Hallo Zusammen,

ich möchte einmal aus der Delphi-Hilfe zitieren:

Zitat:

Alle anderen Methoden eines Handle-Streams zum Lesen von Daten (ReadBuffer, ReadComponent) rufen die Methode Read für den eigentlichen Lesevorgang auf.

gleiches gilt sinngemäß für Write und WriteBuffer

Write/Read-Buffer sind Proceduren denen der Buffer und die Anzahl Bytes übergeben wird. Sollte beim Lesen bzw. Schreiben ein Fehler auftauchen wird eine Exception ausgelöst, die ggf. zu verarbeiten ist.

Read/Write sind Funktionen, denen der der Buffer und die Anzahl Bytes übergeben wird. Zurück gegeben wird die Anzahl der tatsächlich gelesenen/geschriebenen Bytes. Daher Kann man ohne eine Exception-Behandlung auf "Fehler" beim Lesen/Schreiben reagieren.

Für mich ist es daher Geschmackssache welche Routine man einsetzt. Da ich des öfteren das ältere BlockRead/Blockwrite zu ersetzen habe, bevorzuge ich Read und Write.

Delphi-Quellcode:

......
fs:=tfilestream.create(meinedatei);
lies:=x;
repeat
  gelesen:=fs.read(buffer,lies);
  if gelesen >0 then
  {tuwas
  for i:=0 to gelesen-1 do ........ }
until gelesen<>lies;
fs.free;

....

fs:=tfilestream.create(meinedatei);
counter:=0;
lies:=x;
repeat
  try
  fs.readbuffer(buffer,lies);
  {tuwas
  for i:=0 to lies-1 do ........ }
  except
    showmessage('lesefehler');
    exit;
  end;
  inc(counter,1);
until counter>y;
fs.free;
....

Da intern fs.read/fs.write von fs.readbuffer/fs.writebuffer aufgerufen wird sehe ich keinen Grund es nicht gleich zu verwenden.

Gruß
K-H

[himitsu]

@stoxx: SteWriteBuffer: Delphi nutzt schon einen Lese-/Schreibpuffer, allerdings ist dieser 128 Byte groß (also etwas unoptimal und ist standardmäßig direkt in der Datei-Variable eingebaut bzw. an dieser direkt hinten drangehängt)

[isilive]

[quote="Jiron"]

Delphi-Quellcode:

   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;

Hier könntest du später wenn du Lust hast einfach einen Sortieralgorithmus einbauen:
Sortieren

[Jiron]

Hallo isilive

Danke für den Hinweis wo ich wegen dem Sortieren dann schon mal nachsehen kann.
Im Moment versuche ich noch die hier mir im Forum oben angegebenen Beispiele mal durchzuarbeiten. Sowie ich dann mit dem Dateibearbeiten klar komme, mache ich mich an eine effizientere Programmierung.
Noch bekomme ich aber immer wieder die schon oben erwähnte Fehlermeldung:
---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt ProjectLOTTO.exe ist eine Exception der Klasse EInOutError aufgetreten. Meldung: 'E/A-Fehler 6'. Prozeß wurde angehalten. Mit Einzelne Anweisung oder Start fortsetzen.
---------------------------

und das immer wenn das Programm was machen soll, wie z.B.
Write(MyFile,nr) oder BlockWrite (fMyFile, MyFile [1],7);


Und da ich des englischen nicht mächtig bin, haben mir die bisher gefundenen englischen Erlärungen nicht wirklich weiter geholfen - aber wird schon werden.
Gruß und Danke dir
Jiron

[jfheins]

Ich nehme mal an, MyFile bezeichnet bei dir immernoch ein Array (genau das meinte ich mit widersprüchlicher Benennung)

Und wenn du jetzt das hier aufrufst:

Delphi-Quellcode:

Write(MyFile,nr) // oder AssignFile oder Reset oder Rewrite oder Seek

Dann übergibst du der Funktion ein Array und eine Zahl.

Die Funktion hat aber keine Ahnung, in welche Datei Sier schreiben soll.

Das liegt daran: Die Funktion erwartet an erster Stelle einen Dateizeiger. Du übergibt ein Array. Die Funktion versucht nun, das Array als Dateizeiger zu interpretieren. Das geht schief. Also wird dir eine Fehlermeldung um die Ohren gepfeffert ;)
Da die Funktionen ... sagen wir ... seit geraumer Zeit existieren ... ist diese Fehlermeldung jetzt nicht so vielsagend.

Da du dein Array MyFile genannt hast, haben bestimmt einige gedacht, es würde sich schon um einen Dateizeiger handeln - mein Vorschlag: MyData oder Numbers odert sowas.

Was man den Funktionen genau übergeben muss, hat himitsu dir schon hier gezeigt ;)

Ich hoffe, wenigstens etwas von dem stimmt :mrgreen:

[Jiron]

Hallo jfheins

Ich hab mal unten ein Stück Programm aufgeführt, bei dem die o.g. Fehlermeldung in der Zeile:

System.Seek(MyFile,SizeOf(MyFile)); kommt. Jedenfalls ist diese dann makiert.


var
Myfile : file of integer;
Nr: integer ;
FN : string ;
begin
/..............
begin;
AssignFile(MyFile,FN);
{$I-}
if FileExists(FN)then
Reset(MyFile)
else
Rewrite(MyFile);
{$I+}
if IOResult=0 then
begin;
System.Seek(MyFile,SizeOf(MyFile))
Write(MyFile,z1);
end;
CloseFile(MyFile);
end;
/................

Edit8.Text := IntToStr(z1);
end;

Ich bin aber jetzt durch einen Beitrag in diesem Forum auf die Tutorials vom "Delphi-Treff" gestosen und werd mich dort erst mal durcharbeiten. Das wird ja langsan sogar für mich als Anfänger hier peinlich. Ich meld mich dann wieder.
Danke dir aber für deine Mühe.

Und danke noch mal an alle die sich hier gemeldet haben, war echt erstaunt.

Gruß Jiron

[himitsu]

Was soll System.Seek(MyFile,SizeOf(MyFile)) eigentlich bewirken?
in Delphi2009 dürfte SizeOf 720 Byte liefern und davor so 460 Byte ... also würde zum 460-ten bzw. 720-ten Integer gesprungen werden, aber da du die Datei mit Rewrite geöffnet hast, ist diese Datei leer.

[edit] hab mich verguckt: D2009 meint MyFile wäre 592 Byte groß und D7 sagt was von 332 Byte, aber da sieht man mal, wie "unterechenbar" dieser Typ ist :angel2:

[p80286]

Hallo ,

So sollte es etwas sinnvoller sein:

Delphi-Quellcode:

var 
  Myfile : file of integer; 
  Nr: integer ; 
  FN : string ; 
begin 
/.............. 
begin 
  AssignFile(MyFile,FN); 
{$I-} 
  if FileExists(FN)then 
    Reset(MyFile) 
  else 
    Rewrite(MyFile); 
{$I+} 
  if IOResult=0 then 
  begin 
    System.Seek(MyFile,Filesize(MyFile)) 
    Write(MyFile,z1); 
  end; 
  CloseFile(MyFile); 
end; 
/................

Gruß
K-H

edit: verlesen,und geschlampt

[Jiron]

Hallo himitsu und p80286

Danke euch für eure Bemühungen mit mir :-) .
Da ich einfach nicht rausbekam, wo mein Fehler steckt, hab ich mein oberes Beispiel aus dem Buch für Delphi6 von Frank Eller unter "Typisierte Dateien" mal abgeschrieben. Meine Änderung besteht nur darin ( hab bisher jedenfalls keinen Abschreibfehler bei mir gefunden ) das ich anstatt "nr" das "z1" genommen hab. Das ist zwar nicht das was ich nachher wirklich ausgeben möchte, aber mir ging es ja um diese Fehlermeldung. Aber diese Meldung bekomme ich mit dem abgeschriebenen und der jetzt vorgeschlagenen Version, tut mir leid.
Nuja, wie gesagt, ich werd mich mal mit den Tutorials beschäftigen, vielleicht komme ich dann dabei mal drauf wie es richtig sein muß .
Dank noch mal
Gruß Jiron

[himitsu]

@p80286: Anhängen von Daten ginge dann eher so:

Delphi-Quellcode:

begin
  AssignFile(MyFile, FN);
{$I-}
  if FileExists(FN) then
    Append(MyFile)
  else
    Rewrite(MyFile);
{$I+}
  if IOResult = 0 then
  begin
    Write(MyFile, z1);
  end;
  CloseFile(MyFile);
end;

[jfheins]

Wenn du mit den Datei-Funktionen nicht zurechtkommst (is jetzt nicht irgendwie bös gemeint), solltest du mal den Filestream versuchen.

Ich hab mich auch nicht lang mit den Dingern rumgeschlagen (lies: Ich hab zur Kenntnis genommen, dass sie existeren, aber nicht viel mehr) ;)

Diese zwei Methoden, Dateien zu lesen/schreiben sind mindestens gleichwertig, Daten lesen und schreiben geht mit beiden.
Falls mich nicht alles täuscht, sollte der Filestream aber vielseitiger sein, weil man da die Zugriffsart festlegen kann.

[p80286]

@Himitsu

keine Einwände!
Da dieses seek beinahe in jedem TP-Lehrbuch auftaucht (hat da nicht jemand was abgeschrieben?) hab' ich das hier einfach übernommen um Jiron nicht nicht zu verwirren(?).

In meiner Anfangszeit hab ich mich mit den unterschiedlichen "Zugriffsmethoden" ziemlich schwer getan, darum würde ich keinem gleich alle Möglichkeiten um die Ohren hauen.

Gruß
K-H

[himitsu]

Gegen das Seek hab ich ja nix ... nur die verwendeten Parameter-Größen störten etwas ^^

Zitat:

Delphi-Quellcode:

System.Seek(MyFile,SizeOf(MyFile))

aber so viele Möglichkeiten gibt es ja nicht

Reset > Lesen (bzw. Lesen+Schreiben)
Rewrite > Schreiben
Append > Speichern und dabei alles hinten anhängen

Ansonsten muß ich zugeben, daß ich selber fast nur noch direkt über wie WinAPI geh
und bei kleinen Miniprojekten auch mal hin und wieder einfach die "alten" Pascal-Befehle nutz :stupid:

[p80286]

Zitat:

Gegen das Seek hab ich ja nix ..

Hab ich auch nicht angenommen.

Ja das ist wohl die Krux, daß hier jeder von uns inzwischen seine "LieblingsRoutine" hat.
Für mich gibt es praktisch nur Textfiles und manchmal "Binäre Files".

Falls ich Strukturen speichern oder lesen muß, gehe ich in der Zwischenzeit über TFilestream (als Ersatz von Blockwrite/Blockread für "Binäre Files") weil das wahrscheinlich die performanteste Möglichkeit ist, ohne das API zu bemühen.
(falls ich falsch liege, bitte ich um Korrektur!)

Zitat:

System.Seek(MyFile,SizeOf(MyFile))

Das habe ich für einen "Abschreibfehler" gehalten, vor allem weil es diese File/Aarray Konfusion gab.

Ob ich das für mich für sinnvoll halte steht auf einem ganz anderen Blatt.

Gruß
K-H

[himitsu]

Also am Ende geht alles über die WinAPIs CreateFile (manchmal sogar immernoch alte 16-Bit-API ala OpenFile) und ReadFile, sowie WriteFile. :angel2: