[Anfänger] Problem beim Einlesen und Ausgabe von Text Datein

[Didi1887]

Moin, moin

Ich sitze gerade an meiner Semesteraufgabe, komme in einem Punkt nicht weiter und hoffe das ihr mir ein paar Tipps geben könnt.

Und zwar geht es darum, dass das Programm eine Stauplanung für Fässer in einen 20' Container leisten soll (braucht euch ja nicht wirklich zu interessieren).

Auf jeden Fall liegt mein Problem darin, dass eine Text-Datei mit Fass-Nummern eingelesen werden soll und anschließend der Container mit einer bestimmten Anzahl an Fässern beladen werden soll (Anzahl wird durch Programm berechnet). Anschließend soll man eine Text-Datei erstellen, die eine Liste aller verladeten Fässer enthält.

Ich habe mir gedacht, dass ich den Inhalt der ersten Text-Datei mittels Memo1 in das Programm einlesen und dann in ein zweites Memo die Fassnummern übertrage, die laut Programm verladen werden können (z.B. 50 mögliche Fässer --> ersten 50 Nummern in Memo2)
Nun liegt genau darin mein Problem...das Einlesen der Text-Datei ist kein Problem, aber wie kann ich es bewerkstelligen, dass (z.B. bei einer Kapazität von 50 Fässern) die ersten 50 Nummern in Memo2 übernommen werden?

Habt ihr vielleicht einen Tipp? Ihr würdet mir sehr helfen!

Gruß
Didi

[Sir Rufo]

Das mit dem Memo ist schon mal ganz schlecht.

Ein TMemo ist ausschließlich für eine visuelle Darstellung/Erfassung gedacht und nicht für die Logik.

Wenn du den Dateinamen für die Ein und Ausgabedatei, sowie die Anzahl der Fässer hast dann am besten so

Delphi-Quellcode:

procedure VerladeFaesser( const VerladeDatei, ContainerDatei : TFileName; Anzahl : integer );
var
  VerladeListe, ContainerListe : TStrings;
begin
  ContainerListe := TStringList.Create;
  try
    VerladeListe := TStringList.Create;
    try

      VerladeListe.LoadFromFile( VerladeDatei );

      while ( ContainerListe.Count < Anzahl ) and ( VerladeListe.Count > 0 ) do
        begin
          ContainerListe.Add( VerladeListe[ 0 ] );
          VerladeListe.Delete( 0 );
        end;

      ContainerListe.SaveToFile( ContainerDatei );

    finally
      VerladeListe.Free;
    end;
  finally
    ContainerListe.Free;
  end;
end;

[Didi1887]

Schon mal vielen Dank, aber da steige ich leider nicht ganz durch :wink: und so viel Logik muss das ganze für meinen Prof auch nicht haben, da wir hier von relativ einfachen Delphi-Kenntnissen sprechen.

Laut der Aufgabenstellung soll man über einen Button die Textdatei auswählen und eben einlesen und später auch durch einen Speicher-Button die Datei speichern können.

Müsste es nicht auch rein theoretisch so funktionieren, dass man die Datei in ein Memo einliest und anschließend mittels einer for-Schleife sagt i=0 to a (wobei a Anzahl der verladbaren Fässer) und dann eben stumpf von oben nach unten die einzelnen Zeilen in das neue Memo kopiert?

Soweit bin ich bisher, aber es hapert einfach daran, dem Prog. zu sagen, dass es meinetwegen die ersten 50 Zeilen kopieren soll.

Delphi-Quellcode:

procedure TForm1.SpeedButtonOeffnenClick(Sender: TObject);

      var Datei:TextFile;
          Button : Integer;

  begin
  Button:= Application.MessageBox('Klicken Sie auf OK wenn Sie'#13#10'die Containernummern einlesen möchten',
        'Koordinaten',mb_OKCancel+mb_DefButton1);

        if Button=IDOK then
  
           begin
              if OpenDialog.Execute then

                 begin
                   Memo1.Clear;
                   Memo1.Lines.LoadFromFile(OpenDialog.FileName);
                   Memo1.Lines.Count;

[himitsu]

Wenn du mit Stringlisten arbeitest, dann brauchst du

Delphi-Quellcode:

Datei:TextFile;

nicht

Zitat:

Delphi-Quellcode:

Memo1.Clear;
Memo1.Lines.LoadFromFile(OpenDialog.FileName);
Memo1.Lines.Count;

Clear wird von LoadFromFile schon gemacht, ist also nicht unbedingt nötig.
Und Count nur auszulesen bringt nicht viel ... damit sollte man auch noch etwas machen. :wink:

Sir Rufo hat einfach nur die TStringList manuell erstellt, da sie ja eigentlich nicht unbedingt angezeigt werden mnüssen, für die Bearbeitung durch das Programm.

Die manuelle Erzeugung rausgekürzt und auf Memos umgestellt, kommt dieser Code dabei raus.
Sooo viel Logik ist das doch dann garnicht mehr?

Delphi-Quellcode:

// Memo1 = ContainerListe
// Memo2 = VerladeListe
// OpenDialog1 = VerladeDatei
// OpenDialog2 = ContainerDatei
// das, was maximal in einen Container rein passt = Anzahl
begin
  ...
  VerladeListe.LoadFromFile(VerladeDatei.FileName);
  while (ContainerListe.Lines.Count < Anzahl) and (VerladeListe.Lines.Count > 0) do
    begin
      ContainerListe.Lines.Add(VerladeListe.Lines[0]);
      VerladeListe.Lines.Delete(0);
    end;
  ContainerListe.SaveToFile(ContainerDatei.FileName);
end;

Ist noch Platz im Container (ContainerListe) und ist noch etwas in der VerladeListe drin, dann kopiere das Erste aus dieser VerladeListe in die ContainerListe und lösche es dabei aus der VerladeListe...

Tipp: Gib deinen Komponenten ordentliche Namen.
Bei "Memo1" weiß doch keiner wofür das verwendet wird und schon läßt sich der Code besser lesen/verstehen.


Statt dem

Delphi-Quellcode:

while (ContainerListe.Lines.Count < Anzahl) and (VerladeListe.Lines.Count > 0) do

könnte man auch

Delphi-Quellcode:

if VerladeListe.Lines.Count >= 50 then
  for i := 0 to 49 do

machen. (kopiere die ersten 50, wenn es soviele gibt)

Oder man ließt aus, wieviel in VerladeListe drin ist, begrenzt dieses (Max oder über

Delphi-Quellcode:

If i > 50 then i := 50;

) und kopiert, was ausgerechnet wurde.

[Sir Rufo]

Ich habe das einfach mal so geschrieben, wie man das auch in der Realität machen würde:

Delphi-Quellcode:

procedure VerladeFaesser( const VerladeDatei, ContainerDatei : TFileName; Anzahl : integer );
var
  VerladeListe, ContainerListe : TStrings;
begin

  // Ich hole mir schon mal ein leeres Blatt, ich muss ja was aufschreiben :o)

  ContainerListe := TStringList.Create;
  try

    // So mal das Blatt mit den Fässern in die Hand nehmen

    VerladeListe := TStringList.Create;
    try

      // Jetzt lese ich mal, was da so drauf steht

      VerladeListe.LoadFromFile( VerladeDatei );

     // Ok, ich soll also <Anzahl> Fässer in den Container packen

      while  // Solange
        ( ContainerListe.Count < Anzahl )  // im Container nicht <Anzahl> Fässer sind
      and  // und
        ( VerladeListe.Count > 0 )  // und es noch Fässer zum Verladen gibt
      do  // werde ich
        begin
          ContainerListe.Add( VerladeListe[ 0 ] );  // ein Fass in den Container bringen und auf die Pack-Liste schreiben
          VerladeListe.Delete( 0 );  // und dann kann ich das Fass von meiner Verlade-Liste streichen
        end;

      // So, jetzt bin ich fertig mit dem Verladen, jetzt nur noch den Containerinhalt zu Papier bringen

      ContainerListe.SaveToFile( ContainerDatei );

    // Jetzt brauche ich die VerladeListe nicht mehr
    finally
      VerladeListe.Free;
    end;
  // und die ContainerListe kann ich auch weggeben
  finally
    ContainerListe.Free;
  end;
end;

Und effektiv enthält das 5 (!) Zeilen Logik ;) Noch weniger Logik ... nun ja, dein Prof. scheint sehr anspruchslos zu sein ;)

[Didi1887]

Delphi-Quellcode:

// Memo1 = ContainerListe
// Memo2 = VerladeListe
// OpenDialog1 = VerladeDatei
// OpenDialog2 = ContainerDatei
// das, was maximal in einen Container rein passt = Anzahl
begin
  ...
  VerladeListe.LoadFromFile(VerladeDatei.FileName);
  while (ContainerListe.Lines.Count < Anzahl) and (VerladeListe.Lines.Count > 0) do
    begin
      ContainerListe.Lines.Add(VerladeListe.Lines[0]);
      VerladeListe.Lines.Delete(0);
    end;
  ContainerListe.SaveToFile(ContainerDatei.FileName);
end;

Vielen Dank an euch!! So habe ich es hinbekommen.

Das Programm berechnet ja die max. Fässeranzahl pro Container für variable Fässermaße.
Mit der Schleife wird ja ein Container komplett beladen und die Containernummern in die zweite Textdatei geschrieben.

Indem man das erste Memo(Containerliste) durchzählt und durch die Anzahl der verladbaren Fässer pro Container teilt, kommt man ja auf die Gesamtanzahl der benötigten Container.
Ist es jetzt möglich (vielleicht mit einer zweiten Schleife?) einen Container zu beladen und Container1 drunter zu schreiben und dann eben den zweiten Container zu beladen und so weiter und so weiter....das das ganze also in der Textdatei in etwa so aussieht bis alle Fässer verladen sind?(für 10 Fässer pro Container):

Code:

39808
67362
10872
26748
91609
26630
62995
38765
28935
41792
in Container 1
59480
60755
70998
80617
61144
36405
76567
85699
11357
97761
in Container 2
...
...

Gruß
Didi

und nochmals danke...ihr habt mir wirklich sehr geholfen! :)

[Didi1887]

Ich habe es jetzt versucht, das ganze mittels zwei Schleifen zu lösen, aber bei meinen relativ geringen Delphi-Verständnissen und der vielleicht fehlenden Logik, hängt sich das Programm auf bzw. friert ein, da es ja anscheinend in einer Schleife feststeckt? Ist es nicht möglich, zwei Schleifen auf diese Art und Weise zu verknüpfen:?

Delphi-Quellcode:

 begin

        while (Fassliste.Lines.count > 0)  do

          begin

              while (Verladeliste.Lines.count < a) and (Fassliste.Lines.Count > 0)do

            begin
              Verladeliste.Lines.Add(Fassliste.Lines[0]);
              Fassliste.Lines.Delete(0);
            end;

          Fassliste.Lines.Add('--------------------')
        end;

Gruß
Didi

[Jumpy]

Wegen

Code:

while (Fassliste.Lines.count > 0) do

          begin


          Fassliste.Lines.Add('--------------------')
        end;

produzierst du auf jeden Fall eine Endlosschleife, egal, was die innere Schleife macht.