Record laden

[grader]

Guten Abend!

Habe ein Record, welches aus Strings besteht und dieses schreibe ich in eine .Dat Datei. Hier die write Prozedur:

Delphi-Quellcode:

procedure TForm1.saverec;
var
  Stream: TStream;
  I: integer;
  Len: Longint;
begin
  Stream := TFileStream.Create('c:\TMData.dat', fmCreate);
  try
    Len := Length(T);
    Stream.Write(Len, SizeOf(Len));
    for I := 0 to Length(T) - 1 do
    begin
      Len := Length(T[I].B);
      Stream.Write(Len, SizeOf(Len));
      Stream.Write(PChar(T[I].B)^, Len);
    end;
  finally
    Stream.Free;
  end;
end;

Das laden funktioniert auch nur beim ausgeben habe ich ein Problem! Dazu brauche ich die Anzahl der Datensätze, welche ich dann einer Variable n zuordne!

Also wenn ich 5 Termine gespeichert habe steht n auf 5.. Wenn ich jetzt das Programm schließe und das Record wieder lade soll er jetzt n wieder auf 5 setzen!

Habt ihr ne Idee?

Habs so probiert, aber dann sagt er für n immer '1'!

n:=Length(T);

Brauche im Endeffekt nur die Anzahl der Einträge im Record! Muss das Programm leider morgen in Informatik abgeben und sitze schon das ganze WE an diversen Problemen hoffe ihr könnt mir da nochmal helfen :zwinker:

[edit=SirThornberry]Code-Tags durch Delphi-Tags ersetzt und Quelltext eingerückt - Mfg, SirThornberry[/edit]

[MrKnogge]

Die Größe deiner Datei durch SizeOf(DeinRecord) teilen.

Gruß

[himitsu]

Oder die Datei bis zum Dateiende (EndOfFile) abarbeiten und jeweils den grad gelesenen Eintrag anhängen,

aber du hast doch die Anzahl in der Datei abgespeichert?
Also brauchst du die doch einfach nur auszulesen. :gruebel:

Delphi-Quellcode:

Stream.Read(Len, SizeOf(Len)); 
SetLength(T, Len); 
for I := 0 to Length(T) - 1 do 
begin 
  Stream.Read(Len, SizeOf(Len)); 
  SetLength(T[I].B, Len);
  Stream.Read(PChar(T[I].B), Len); 
end;

[grader]

Und wie lese ich die jetzt genau aus? Sorry, bin entweder zu blöd oder überhaupt nicht mehr aufnahmefähig heute :wall:

edit:

habe jetzt so gemacht:

Delphi-Quellcode:

Stream.Read(Len, SizeOf(Len)); 
SetLength(T, Len);
n:=Length(T);

jetzt kommt aber immer ne Exception!! help please :zwinker:

edit2:

das war jetzt glaube ich noch größerer Blödsinn :spin2:

verstehe aber nicht warum es mit

Delphi-Quellcode:

n:=Length(T);

nicht geht??

[grader]

Bitte bräuchte wirklich noch nen Tipp, da das Programm ohne das sinnlos wäre :roll:

Will doch nur die Anzahl der Datensätze des Records in eine Variable stecken!

[bitsetter]

Hallo,

normalerweise müsste es funktionieren. Hast du beim Laden der Datei auch mit fmOpenRead gearbeitet?

Delphi-Quellcode:

Stream := TFileStream.Create('c:\TMData.dat', fmOpenRead);

Ansonsten zeige uns mal den Rest deines Codes.

EDIT:

Zitat:

Zitat von MrKnogge

Die Größe deiner Datei durch SizeOf(DeinRecord) teilen.

Gruß

Delphi-Quellcode:

Len := stream.Size div SizeOf(T);

[Luckie]

Zitat:

Zitat von grader

Habe ein Record, welches aus Strings besteht

AnsiStrings in einem Record kann man nicht so einfach in eine Datei schreiben. Zeig mal deinen Record und deine Speicher-Routine.

[himitsu]

Delphi-Quellcode:

    Len := Length(T); 
    Stream.Write(Len, SizeOf(Len)); 
    for I := 0 to Length(T) - 1 do 
    begin 
      Len := Length(T[I].B); 
      Stream.Write(Len, SizeOf(Len)); 
      Stream.Write(PChar(T[I].B), Len);

sieht eigentlich OK aus, wenn B der String ist

er speichert die Arraylänge und dann jeweils die Länge von B, sowie dessen Inhalt?

[edit]
getäucht ... ein ^ zuviel

[TStringlist]

hallo grader,

der erste Parameter der Stream.Write- und Stream.Read-Funktionen muss immer die Adressen der Variablen sein, welche man damit auslesen bzw. beladen will, also ungefähr so:

Delphi-Quellcode:

Stream.Write(Addr(Len)^, SizeOf(Len));

bzw.

Stream.Read(Addr(Len)^, SizeOf(Len));

edit: wenn das der Compiler nicht schon automatisch macht :mrgreen:

[himitsu]

Nein, Read/Write nimmt verwendet Var/Const-Parameter (D7) und demnach nichts mit Addr und Co.

Weßhalb auch die Dereferenzierung im Ausgangspost falsch wäre.

Code:

Stream.Write(PChar(T[I].B)[color=#ff0000][b]^[/b][/color], Len);

dat Rote muß weg, denn sonst kann es mit dem Auslesen nicht klappen ... da ja schon was Falsches in der Datei stünde.

PS: hattest du eigentlich mal in die Datei geschaut, also ob da überhaupt was richtig Aussehendes drin ist?

[grader]

Hallo!

Danke euch erstmal für eure Hilfe! Jetzt sieht es so aus:

Delphi-Quellcode:

procedure TForm1.saverec;
var
  Stream: TStream;
  I: integer;
  Len: Longint;
begin
Stream := TFileStream.Create('c:\TMData.dat', fmCreate);
try
Len := Length(T);
Stream.Write(Len, SizeOf(Len));
for I := 0 to Length(T) - 1 do
begin
Len := Length(IntToStr(T[I].T));
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].T), Len);
Len := Length(IntToStr(T[I].M));
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].M), Len);
Len := Length(IntToStr(T[I].J));
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].J), Len);
Len := Length(T[I].Zh);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].Zh), Len);
Len := Length(T[I].Zm);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].Zm), Len);
Len := Length(T[I].B);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].B), Len);
Len := Length(T[I].T1);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].T1), Len);
Len := Length(T[I].T2);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].T2), Len);
Len := Length(T[I].T3);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].T3), Len);
Len := Length(T[I].T4);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].T4), Len);
Len := Length(T[I].P);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].P), Len);
Len := Length(T[I].N);
Stream.Write(Len, SizeOf(Len));
Stream.Write(PChar(T[I].N), Len);
end;
finally
Stream.Free;
end;
end;

und

Delphi-Quellcode:

procedure TForm1.loadrec;
var
  Stream: TStream;
  I: integer;
  Len: LongInt;
begin
  Stream := TFileStream.Create('c:\TMData.dat', fmOpenRead);
  try
  Stream.Read(Len, SizeOf(Len));
  SetLength(T, Len);
for I := 0 to Len - 1 do
begin
{Stream.Read(Len, SizeOf(Len));
SetLength(T[I].T, Len);
Stream.Read(PChar(T[I].T), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].M, Len);
Stream.Read(PChar(T[I].M), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].J, Len);
Stream.Read(PChar(T[I].J), Len);}
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].Zh, Len);
Stream.Read(PChar(T[I].Zh), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].Zm, Len);
Stream.Read(PChar(T[I].Zm), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].B, Len);
Stream.Read(PChar(T[I].B), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].T1, Len);
Stream.Read(PChar(T[I].T1), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].T2, Len);
Stream.Read(PChar(T[I].T2), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].T3, Len);
Stream.Read(PChar(T[I].T3), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].T4, Len);
Stream.Read(PChar(T[I].T4), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].P, Len);
Stream.Read(PChar(T[I].P), Len);
Stream.Read(Len, SizeOf(Len));
SetLength(T[I].N, Len);
Stream.Read(PChar(T[I].N), Len);
end;
  finally
    Stream.Free;
  end;
end;

Jetzt markiert er folgendes rot und sagt "variable required":

Delphi-Quellcode:

Stream.Write(PChar(T[I].T), Len);

Dieses Tut habe ich übrigens verwendet..
Und da steht das mit dem "^" drin und so geht es auch zu kompilieren geht nur net :gruebel:

Gruß
Stefan

Edit:

hab jetzt noch das hier gefunden, was ich vielleicht später mal probieren werde:

klick

Jetzt hab ich aber erstmal andere Sorgen, morgen letzte Kursarbeit in Physik :roll:

[himitsu]

Dann halt so?

Delphi-Quellcode:

Stream.Write(T[I].B[1], Len);

Aber wie schon mehrmals gefragt ... wie sieht denn die Definition deines Records aus?

[grader]

Delphi-Quellcode:

type
  TDatum = record
  T,M,J: word;
  Zh,Zm,B,O,T1,T2,T3,T4,P,N: String;
end;

und

Delphi-Quellcode:

var
  T: array of TDatum;

Achso wenn ich das aus deinem letzten Post nehme, sagt er nur Array type required! Außerdem verstehe ich nicht ganz was das bewirken soll :gruebel:

[himitsu]

müßte stimmen

Delphi-Quellcode:

// Schreiben
Len := Length(T);
Stream.Write(Len, SizeOf(Len));
for I := 0 to Length(T) - 1 do
begin
  Stream.Write(T[I].T, SizeOf(Word) * 3);  // .T, .M und .J zusammen
  Len := Length(T[I].Zh);
    Stream.Write(Len, SizeOf(Len));
    If Len > 0 Then Stream.Write(T[I].Zh[1], Len);
  Len := Length(T[I].Zm);
    Stream.Write(Len, SizeOf(Len));
    If Len > 0 Then Stream.Write(T[I].Zm[1], Len);
  Len := Length(T[I].B);
    Stream.Write(Len, SizeOf(Len));
    If Len > 0 Then Stream.Write(T[I].B[1], Len);
  ...
  Len := Length(T[I].N);
    Stream.Write(Len, SizeOf(Len));
    If Len > 0 Then Stream.Write(T[I].N[1], Len);
end;


// Lesen
Stream.Read(Len, SizeOf(Len));
SetLength(T, Len);
for I := 0 to Length(T) - 1 do
begin
  Stream.Read(T[I].T, SizeOf(Word) * 3);  // .T, .M und .J zusammen
  Stream.Read(Len, SizeOf(Len));
    SetLength(T[I].Zh, Len);
    If Len > 0 Then Stream.Read(T[I].Zh[1], Len);
  ...
  Stream.Read(Len, SizeOf(Len));
    SetLength(T[I].N, Len);
    If Len > 0 Then Stream.Read(T[I].N[1], Len);
end;

Stream.Read/Write wollen ja einen Var/Const-Parameter, welcher auf den Stringinhalt zeigt und dieser beginnt beim 1. Zeichen.


Anders gesagt ... die Implementation von Stream.Read/Write ist sch*** :angel2:


Ach ja, da der Zugriff auf [1] nicht möglich ist, wenn der String leer ist, muß halt nich mit IF dieser Zustand abgefangen werden.
Wenn du garantieren kannst, daß die strings immer mit mindestens einem Zeichen gefüllt sind, dann kannst du natürlich die IF-Abfragen weglassen und direkt Schreiben/Lesen.

[grader]

Du warst schneller, werds gleich mal probieren!

[Chemiker]

Hallo grader,

schau dir mal das Tut. ‚Records in einem FileStream speichern’ an. Ich würde nicht lange Strings verwenden, sondern kurze Strings, wenn das Möglich ist. Bei langen String muss immer die Länge der Strings mit verwaltet werden, dies ist sehr aufwendig.
Bei kurzen Strings ist der Record immmer gleich groß.

statt:

Delphi-Quellcode:

type 
  TDatum = record 
  T,M,J: word; 
  Zh,Zm,B,O,T1,T2,T3,T4,P,N: String; 
end;

Delphi-Quellcode:

const strLaenge= 20; // Strings sind 20 Zeichen lang.
type 
 TDatum = packed record
    T:  Word;
    M:  Word;
    J:  Word;
    Zh: string[strLaenge];
    Zm: string[strLaenge];
    B:  string[strLaenge];
    O:  string[strLaenge];
    T1: string[strLaenge];
    T2: string[strLaenge];
    T3: string[strLaenge];
    T4: string[strLaenge];
    P:  string[strLaenge];
    N:  string[strLaenge];
 end;

Bis bald Chemiker

[grader]

Boah habs jetzt probiert und Ernüchterung folgte zugleich.. Ging wieder nicht :wall:

Hab aber auch rausgefunden warum:

Delphi-Quellcode:

for I := 0 to Length(T) - 1 do

Hab Length(T) testweise durch eine Zahl ersetzt und voila es funktioniert! Dann hab ich mir Length(T) mal ausgeben lassen und egal wie viele Einträge vorhanden sind er gibt immer nur "1" aus! Es nimmt halt kein Ende, aber ich glaube jetzt isses nicht mehr weit ;)

@Chemiker

Ja das hatte ich auch schon mal gelesen, aber irgendwie hatte ich dann an anderen Stellen Probleme mit den ShortStrings zu arbeiten.. Is aber auch schon ein Stück her, werds dann nochmal probieren, THX :)

[himitsu]

Stream.Read/.Write sind doch bei dir so definiert?

Delphi-Quellcode:

Read(var Buffer; Count: Longint): Longint;
Write(const Buffer; Count: Longint): Longint;

Also dann sollte es doch funktionieren? :gruebel:

Hast du mal ein Testprogramm zur Verfügung?




Jedenfalls zu Chemiker's Vorschlag:
strLaenge = maximale StringLänge (mehr geht dann nicht rein und soviel wird auch immer gespeichert, selbt wenn weniger drin ist)

Delphi-Quellcode:

// Schreiben
Len := Length(T);
Stream.Write(Len, SizeOf(Len));
for i := 0 to Length(T) - 1 do
  Stream.Write(T[i], SizeOf(TDatum));

// Lesen
Stream.Read(Len, SizeOf(Len));
SetLength(T, Len);
for i := 0 to Length(T) - 1 do
  Stream.Read(T[i], SizeOf(TDatum));

Bei 'nen packed Array (ebenfalls mit ShortStrings) müßte es auch so gehn:

Delphi-Quellcode:

// Schreiben
Len := Length(T);
Stream.Write(Len, SizeOf(Len));
Stream.Write(T[0], SizeOf(TDatum) * Length(T));

// Lesen
Stream.Read(Len, SizeOf(Len));
SetLength(T, Len);
Stream.Read(T[0], SizeOf(TDatum) * Length(T));

[grader]

ööhm ich glaube nicht aber ich weiß auch grad net wie und wo :angel2:

Hab dir mein Prog mal in den Anhang geladen, aber ohne die .EXE..

Und bitte nicht wundern, da sind 6 Units, aber ich benutze nur eine, wenn ich die anderen aber lösche gehts net mehr..

[Chemiker]

Hallo grader,

Zitat:

Zitat von himitsu

strLaenge = maximale StringLänge (mehr geht dann nicht rein und soviel wird auch immer gespeichert, selbt wenn weniger drin ist)

Das sollte aber bei den heutigen Festplatten keine Problem sein.


Vieleicht hilft dir das weiter:

Delphi-Quellcode:

unit FileStreamHilfeUnit1;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Edit4: TEdit;
    Edit5: TEdit;
    Edit6: TEdit;
    Edit7: TEdit;
    Edit8: TEdit;
    Edit9: TEdit;
    Edit10: TEdit;
    Edit11: TEdit;
    Edit12: TEdit;
    Edit13: TEdit;
    Edit14: TEdit;
    Edit15: TEdit;
    Edit16: TEdit;
    Edit17: TEdit;
    Edit18: TEdit;
    Edit19: TEdit;
    Edit20: TEdit;
    Edit21: TEdit;
    Edit22: TEdit;
    Edit23: TEdit;
    Edit24: TEdit;
    Edit25: TEdit;
    Edit26: TEdit;
    Button1: TButton;
    Button2: TButton;
    DatenSatzNr: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

const strLaenge= 20; // Strings sind 20 Zeichen lang. 
type
TDatum = packed  record
    T:  Word;
    M:  Word;
    J:  Word;
    Zh: string[strLaenge];
    Zm: string[strLaenge];
    B:  string[strLaenge];
    O:  string[strLaenge];
    T1: string[strLaenge];
    T2: string[strLaenge];
    T3: string[strLaenge];
    T4: string[strLaenge];
    P:  string[strLaenge];
    N:  string[strLaenge];
end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function Stream_MW_Rec_Anhaengen
                           (f: TFileStream; MWRec: TDatum): boolean;
begin
  try
    f.Position:=0; 
    f.Seek(0, soFromEnd);    // Datenzeiger auf das Ende des Streams setzen.
    f.WriteBuffer(MWRec, SizeOf(TDatum));
    result:= TRUE; 
  except
    ShowMessage('Es ist beim Datensatz speichern ein Fehler aufgetreten!');
    result:= FALSE; 
  end;
end;
function Stream_MW_Rec_Lesen (f: TFileStream; var MWRec: TDatum;
                              DatensatzNr: integer): boolean;
begin 
  try 
    f.Position:=0; 
    // An dieser Stelle wird der Datei-Zeiger auf den zu lesenden
    // Datensatz gestellt. Durch -soFromBeginning- wird der Dateizeiger 
    // auf den Anfang gesellt. 
    f.Seek((SizeOf(TDatum)*DatensatzNr), soFromBeginning);
    f.ReadBuffer(MWRec, SizeOf(TDatum));
    result:= TRUE;
  except 
    ShowMessage('Es ist beim Datensatz lesen ein Fehler aufgetreten!'); 
    result:= FALSE; 
  end; 
end;

function Stream_MW_Rec_DatenSatzAnzahl 
                   (f: TFileStream; MWRec: TDatum): integer;
begin 
  result:= 0;
  if f.Size>0 then
  begin 
    // Berechnung: Gesamte Stream-Lämge / TMW_Stream_Rec 
    // Das ergibt die Datensatz-Anzahl 
    result:= trunc(f.Size/SizeOf(TDatum));
  end; 
end;

function Stream_oeffnen (var f: TFileStream ;const DateiName: string): boolean;
begin
  result:= TRUE; 
  try 
    {-- FileStream zum Lesen u. Schreiben uneingeschränkt öffnen    -----------} 
    f:= TFileStream.Create(DateiName, fmOpenReadWrite or fmShareDenyNone) 
  except
    try 
     { FileStream neu anlegen, tritt hier ein Fehler auf so wird das Prg. ab-  } 
     { gebrochen und zur der aufrufende Routine zurückgesprungen.              } 
     f:= TFileStream.Create(DateiName, fmCreate or fmShareDenyNone); 
    except
      ShowMessage('Fehler beim Erzeugen der Datei:'+#13+DateiName); 
      Exit;  // Zur aufrufenden Routine zurück. 
    end; 
    result:= FALSE; 
  end;
end; 

procedure TForm1.Button1Click(Sender: TObject);
var f: TFileStream;
    TDatum_Rec: TDatum;
begin
  with TDatum_Rec do
  begin
    T:=  strtoint(Edit1.Text);
    M:=  strtoint(Edit2.Text);
    J:=  strtoint(Edit3.Text);
    Zh:= Edit4.Text;
    Zm:= Edit5.Text;
    B:=  Edit6.Text;
    O:=  Edit7.Text;
    T1:= Edit8.Text;
    T2:= Edit8.Text;
    T3:= Edit9.Text;
    T4:= Edit10.Text;
    P:=  Edit11.Text;
    N:=  Edit12.Text;
  end;
  Stream_oeffnen (f ,'f:\TMData.dat');
  Stream_MW_Rec_Anhaengen (f, TDatum_Rec);
  f.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);
var f: TFileStream;
    TDatum_Rec: TDatum;
begin
  Stream_oeffnen (f ,'c:\TMData.dat');
  Stream_MW_Rec_Lesen (f, TDatum_Rec, strtoint(DatensatzNr.Text)-1);
  with TDatum_Rec do
  begin
    Edit14.Text:= inttostr(T);
    Edit15.Text:= inttostr(M);
    Edit16.Text:= inttostr(J);
    Edit17.Text:=Zh;
    Edit18.Text:=Zm;
    Edit19.Text:=B;
    Edit19.Text:=O;
    Edit20.Text:=T1;
    Edit21.Text:=T2;
    Edit22.Text:=T3;
    Edit23.Text:=T4;
    Edit24.Text:=P;
    Edit25.Text:=N;
  end;
end;

end.

Bis bald Chemiker

[shmia]

Records in Dateien zu speichern macht nur in Ausnahmefällen einen Sinn.
Sobald man in einem Record nur eine einzige Variable hinzunimmt, knallts an allen Ecken, da nun die Recordlänge verändert wurde.
Heutzutage (im 21. Jahrhundert) braucht man eine robuste, selbsterklärende Datenstruktur innerhalb der Datei.
Das einfachste sind INI-Dateien.
Deutlich flexibler (aber auch komplexer) sind XML-Dateien.
Für kompakte Datenhaltung kann man auch den Mechanismus von IFF ( http://de.wikipedia.org/wiki/Interchange_File_Format ) abschauen:
Jeder Datenwert besteht aus einer ID (4 Bytes), gefolgt von einer Längenangabe (4 Bytes), gefolgt von den eigentlichen Nutzdaten.

[himitsu]

Abgesehn davon, daß an dem Program rein garnichts geht und die CodeFormatierung grad noch so ansatzweise zu erkennen ist .... ähhhhhhh?

Also bei Beenden wirdja versucht 4 einträge zu speichern, selbst wenn das Array leer ist.
Wärend Len aber mit der tatsächlichen Zahl gepeichert wird.
- beim Auslesen kann da also nichts stimmen (Len <> gepeicherte Datensätze)
- gespeichert kann aber sowieso nichts werden, da ja auf nichts zugegriffen wird

die Arraylänge solltest du besser aus dem Array lesen und nicht über eine nichtssagende globale Variable (n) ... vorallem wenn du die Arraygröße nicht anpasst.

Ich dachte ja .. OK, wenn der schon so speichern will, dann füge ich mal ein paar (mindestens 4) Einträge ein, aber Button2Click verreckt ja auch.


Also erstmal wäre es wohl gut, wenn du den Variablen "schöne" Namen gibst, damit man auch weiß wofür die sind.

statt n := n + 1; würde sich eine lokale Variable für "n" anbieten und dann folgendes

Delphi-Quellcode:

n := Length(T);
SetLength(T, n + 1);

OK, also hab ich dann erstmal das globale "n" aus der Unit1 gelöscht und wolte sehn wo das verwendet wurde, aber die erwartete Fehlermeldung "n ist nicht delkariert" kam nicht .. was war das für ein schock, also ich dann in Unit2 noch eine globale Variable mit dem selben Namen fand.

Also ehrlich ... es ist wirklich besser, wenn du erstmal diese Dinge verbesserst, bevor ich hier noch ein paar n's finde :wall:

[grader]

Danke dir für deine Mühe Chemiker, kanns mir aber erst später anschauen da ich noch für Physik lernen muss :thumb:

@shmia

Mein eigentliches vorhaben war es in einer XML zu speichern und da gab es auch ein schönes Tutorial irgendwo, doch irgendwie hat bei meiner Delphi Version ein Menüpunkt gefehlt, was das weitere Vorgehen vereitelt hat.. Und da es "nur" ein Projekt für den Informatikunterricht sein soll und wir gerade mal ein Halbjahr in Delphi programmiert haben (mehr schlecht als recht) hab ich mich dann für die Methode entschieden.. Aber wenn das alles läuft werd ich das wohl nochmal in Erwägung ziehen!

@himitsu

Also das gar nichts geht würd ich mal nicht behaupten, dass es ziemlich wirr programmiert ist geb ich zu, da ich andauernd irgendwas geändert habe.. Bin halt Anfänger, da probiert man viel rum und vergisst dann mal hier und da was zu löschen oder bringt Variablen durcheinander!

Werd morgen den Quelltext mal etwas aufräumen, doch was hat es mit den Units 2-6 auf sich? Die hab ich in Delphi entfernt, doch anscheinend ist Unit1 von denen immernoch abhängig!

[grader]

Hallo Leute!

Ich bins nochmal, bin grad am aufräumen des Quelltextes und habe schon unnötige bzw. doppelte Variablen entfernt und habe jetzt folgendes Problem bin schon kurz vorm verzweifeln!

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var Jahr, Monat, Tag: word;
begin
  SetLength(T, Length(T) + 1);
  DecodeDate(DateTimePicker1.Date, Jahr, Monat, Tag);
  T[Length(T)].J:=Jahr;
  T[Length(T)].M:=Monat;
  T[Length(T)].T:=Tag;
  T[Length(T)].Zh:=Edit1.Text;
  T[Length(T)].Zm:=Edit2.Text;
  T[Length(T)].B:=Edit8.Text;
  T[Length(T)].O:=Edit3.Text;
  T[Length(T)].T1:=Edit4.Text;
  T[Length(T)].T2:=Edit5.Text;
  T[Length(T)].T3:=Edit6.Text;
  T[Length(T)].T4:=Edit7.Text;
  T[Length(T)].P:=IntToStr(p);
  T[Length(T)].N:=RichEdit1.Text;
end;

Bei Form1.Show wird SetLength(T, 0) ausgeführt und er setzt auch nach jedem Klick Length(T) um eins nach oben wie gewollt..

ABER: Irgendwie haut das nicht hin, ich kann einen Eintrag (z.B. T[2].B) nur direkt nach dem erstellen ausgeben, sobald ich wieder einen neuen erstelle gibts er nichts ("") aus!

:wall: :wall: :wall:

[Hawkeye219]

Hallo,

der höchste Index, den du verwenden darfst, hat den Wert High(T), nicht Length(T).

Gruß Hawkeye

[TStringlist]

...soll auch heißen: Ein Element T[Length(T)] gibt es nicht, weil das erste Element bei dynamischen Arrays immer den Index 0 besitzt! Ergo hat das letzte Element den Index: Length(T)-1

Delphi-Quellcode:

T[Length(T)-1] := ....

[grader]

Öhm das mit dem High hab ich nicht so ganz verstanden, aber mit T[Length(T)-1] funktioniert es :thumb:

Danke euch

[Hawkeye219]

Zitat:

Zitat von grader

Öhm das mit dem High hab ich nicht so ganz verstanden

Hier ist etwas zum Auffrischen deiner Kenntnisse: DSDT-Link
Insbesondere der Abschnitt "Dynamische Arrays" dürfte in diesem Zusammenhang interessant sein.

Gruß Hawkeye

[grader]

werds mir mal durchlesen :zwinker: