Informaticasite van het Lauwers College te Buitenpost                 © R.J. van der Beek
 

Delphi Hoofdstuk 4. Bestanden lezen en schrijven; herhalen.

We gaan op deze pagina bekijken hoe je een tekstbestand op de schijf kunt opslaan, en ook weer op kunt vragen.

Verder gaan we bespreken op welke manieren je een tekstbestand op het scherm kunt laten zien:
  • In een memobox
  • In een imagebox

  4.1. Een tekstbestand maken.

Begin met een nieuw project, het formulier moet er uitzien zoals hiernaast.

Zet dus bovenaan een label met het opschrift : "Naam bestand ", en daarnaast een tekstbox waar de naam kan worden ingevoerd.
Geef het label de naam lblBestand en geef het tekstvenster de naam txtBestand

Zet daaronder een button met het opschrift "Maak bestand aan", geef de button als naam cmdMaakbestand

Een eindje daaronder komt nog een editbox, waarin tekst kan worden ingevoerd, die dan in het bestand moet worden opgeslagen.
Geef dat tekstvenster als naam txtRegel

Daar weer onder een button met het opschrift "Voeg deze regel toe aan bestand" en dan nog een button met het opschrift "Sluit af".
De namen van deze buttons luiden cmdVoegtoe en cmdSluitaf

De laatste drie objecten moeten in het begin eigenlijk nog niet op het scherm staan.
Want eerst moet er ruimte voor het bestand gemaakt worden op de schijf, voordat er echt iets in gezet kan worden.

Daarom zet je in de procedure bij Form_Create het volgende :

procedure TForm1.FormCreate(Sender: TObject);

begin
      txtRegel.Visible := False;
      cmdVoegtoe.Visible := False;
      cmdSluitaf.Visible := False;

end;

Verder is het de bedoeling dat er, als er op de button met "Maak bestand aan" wordt geklikt, er op de schijf ruimte wordt gecreëerd voor het bestand, en dat er ook op de schijf wordt aangegeven wat de naam van dat bestand is (het is de bedoeling dat die naam in het tekstvenster er boven is ingevoerd), zodat er echt iets in dat bestand geplaatst kan worden.

Als de naam van het bestand "PROEF.TXT" moet zijn dan is de opdracht die dat verzorgt het volgende :
ASSIGN(f,'PROEF.TXT');

Wij kennen de naam echter nog niet, dat hangt er vanaf wat er in het tekstvenster wordt ingevoerd. Daarom wordt die naam in een variabele vastgelegd, die ik "bestandsnaam" heb genoemd.

Door de opdracht bestandsnaam := txtBestand.Text + '.TXT'; wordt er nog .TXT aan de naam, die in de editbox is ingevoerd, toegevoegd.

Verder kunnen dan de eerste drie objecten verdwijnen, en de laatsten moeten zichtbaar worden, daarom moeten er een aantal opdrachten met "visible" worden toegevoegd.

Dubbelklik op de button met "Maak bestand aan" en voer de volgende regels bij
procedure TForm1.cmdMaakbestandClick(Sender: TObject); in:

procedure TForm1.cmdMaakbestandClick(Sender: TObject);

var bestandsnaam: String;
      // declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
      bestandsnaam := txtBestand.Text + '.txt';
      // het bestand met de ingevoerde naam wordt aangemaakt
      assignFile(f,bestandsnaam);
      // de schrijfwijzer wordt aan het begin van het bestand gezet
      REWRITE(f);
      // als je iets wilt toevoegen aan een bestand (dus niet vanaf het begin wilt schrijven)
      // gebruik dan APPEND(f); in plaats van REWRITE(f);
      lblBestand.Visible := False;
      txtBestand.Visible := False;
      cmdMaakbestand.Visible := False;
      txtRegel.Visible := True;
      cmdVoegtoe.Visible := True;
      cmdSluitaf.Visible := True;
end;

end;

De tekstfile moet je als globale variabele declareren, omdat hij in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste staat er al)

var
      Form1: TForm1;
      // declaratie van de file
      f:textFile;

  4.2. Iets in een tekstbestand zetten.

Het is de bedoeling dat als je in het tweede tekstvenster een regel intikt, en je klikt op "Voeg deze regel aan bestand toe" dat die regel in het bestand wordt gezet.
Als je de opdracht WRITELN(f,'Piet is gek'); geeft, dan wordt de zin "Piet is gek" aan het bestand toegevoegd.

Bij ons programma moet de regel die in de tekstbox txtRegel is ingetypt aan het bestand worden toegevoegd. Dat gaat als volgt :

Dubbelklik op het label "Voeg deze regel aan bestand toe" en zorg dat er het volgende staat:

procedure TForm1.cmdVoegtoeClick(Sender: TObject);
begin
      WRITELN(f,txtRegel.Text);
      txtRegel.Text := '';
end;

De laatste regel heeft tot gevolg dat de tekstbox weer leeg wordt gemaakt voor de volgende regel.
Elke keer als er op de button "Voeg deze regel aan bestand toe" wordt geklikt wordt er iets aan het bestand toegevoegd. Je kunt het dus zo lang maken als je wilt.

Voer verder nog bij de button "Sluit af" het volgende in :

procedure TForm1.cmdSluitafClick(Sender: TObject);
begin
      Closefile(f);
end;

Door de opdracht CloseFile(f) wordt het bestand "afgesloten", er kan daarna niets meer (rechtstreeks) worden toegevoegd.

Als je het programma helemaal klaar hebt laat je het lopen (RUN !)
Voer als bestandsnaam in: PROEF en klik dan op MAAK BESTAND AAN.
Voer daarna minstens 10 regels in, en voeg die steeds aan het bestand toe.
Sluit dan af, dan stopt het programma.

Start dan KLADBLOK en kijk of het bestand PROEF.TXT bestaat (het zit waarschijnlijk in de map van het Delphi-project) en wat er in zit.
Als alles goed is gegaan dan zitten de regels er in die je hebt ingevoerd met het programma.

  4.3. Een tekstbestand inlezen.

Begin met een nieuw project, het formulier moet er uit zien zoals hiernaast.

Zet dus bovenaan een label met het opschrift : "Naam bestand ", en daarnaast een editbox waar de naam kan worden ingevoerd.
Geef het label de naam lblBestand en geef de editbox de naam txtBestand

Zet daaronder een button met het opschrift "Lees begin", geef de button als naam cmdLees
Naast de button cmdLees zet je nog een button met het opschrift "Lees volgende regel" en geef de button als naam cmdVolgenderegel
Daaronder links een memobox, waarin de tekst kan worden getoond.
Het verschil tussen een memobox en een editbox is, dat in een editbox maar één regel tekst kan, en in een memobox kunnen meerdere regels.
Geef die memobox als naam memoAfdruk, en zorg er voor dat er een horizontale en een verticale scrollbar is (klik op Scrollbars in het propertiesvenster, en kies dan voor ssBoth)

Daarnaast rechts een imagebox, waarin de tekst ook kan worden getoond.
Geef die imagebox als naam imgAfdruk

Onderaan nog een button met het opschrift "Sluit af".
De naam van deze button is cmdSluitaf

Het is de bedoeling dat als je de naam van een tekstbestand invoert, en dan op de button cmdLees klikt dat de inhoud ervan in de memobox er onder wordt getoond en ook in de imagebox.
Dat gaan we nu programmeren.
Dubbelklik op de button met "Lees begin" en voer de volgende regels bij
procedure TForm1.cmdLeesClick(Sender: TObject); in:

procedure TForm1.cmdLeesClick(Sender: TObject);

var bestandsnaam, regel: String;
      // declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
      bestandsnaam := txtBestand.Text + '.txt';
      // het bestand met de ingevoerde naam wordt geopend
      assignFile(f,bestandsnaam);
      // de leeswijzer wordt aan het begin van het bestand gezet
      reset(f);
      readln(f, regel);
      memoAfdruk.text := regel;
      imgAfdruk.Canvas.TextOut(0,0,regel);
      lblBestand.Visible := False;
      txtBestand.Visible := False;
      cmdLees.Visible := False;
end;

end;

De opdracht bestandsnaam := txtBestand.text + ".txt" heeft tot gevolg dat de naam van het tekstbestand, dat ingelezen moet worden in de variabele "bestandsnaam" (daar kan een string in, zie eerste programmaregel) wordt vastgelegd. Daarvoor wordt in de editbox txtBestand gekeken, en wat daar staat daar wordt .txt achter geplakt.
Als je dus in het tekstvenster PROEF intikt dan komt er in "naambestand" te staan: "PROEF.txt"

assignFile(f,bestandsnaam); heeft tot gevolg dat het volgende gebeurt:
Als er in de variabele bestandsnaam PROEF.txt staat, dan had er in de opdracht net zo goed kunnen staan:
assignFile(f,'PROEF.txt');
Het bestand PROEF.txt wordt dan opgezocht op de schijf (in dezelfde map waarin het programma staat; als het daar niet staat moet het pad er bij).
En er wordt een buffergeheugen met de naam f in het werkgeheugen gereserveerd, waarin de ingelezen regels eerst worden geplaatst.

De opdracht reset(f); heeft tot gevolg dat de leeswijzer aan het begin van het bestand wordt gezet; het programma houdt d.m.v. de leeswijzer bij tot hoever het bestand is ingelezen.
readln(f, regel); heeft tot gevolg dat er een regel van het bestand wordt ingelezen (eigenlijk gaat dat in twee stappen: eerst wordt er een gedeelte van het bestand (bijvoorbeeld 1024 bytes, dat is hier waarschijnlijk het hele bestand) in de buffer met de naam f gezet. En dan wordt uit die buffer de eerste regel gelezen en in de variabele "regel" (die is van het type string, zie de eerste programmaregel) vastgelegd).

memoAfdruk.text := regel; heeft tot gevolg dat deze eerste regel in de memobox memoAfdruk getoond wordt.

imgAfdruk.Canvas.TextOut(0,0,regel); heeft tot gevolg dat deze eerste regel ook in de imagebox imgAfdruk getoond wordt, en wel vanaf de plaats (0,0) dus bovenaan.
Een imagebox kun je voor plaatjes gebruiken, maar dus ook voor tekst!

De laatste drie programmaregels hebben tot gevolg dat de eerste drie objecten van het scherm verdwijnen, die zijn dan niet meer nodig.

Laat het programma nu lopen, voer als bestandsnaam PROEF in, en als je geen fouten hebt gemaakt dan wordt de eerste regel van dat tekstbestand getoond in het linker tekstvenster en ook in de rechter imagebox.
Je moet natuurlijk wel zo'n tekstbestand hebben ingevoerd, zoals in 4.2. is uitgelegd.
De tekstfile moet je als globale variabele declareren, omdat hij in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste staat er al)

var
      Form1: TForm1;
      // declaratie van de file
      f:textFile;

  4.4. De volgende regels inlezen.

Het is de bedoeling dat als je op de button "Lees volgende regel" klikt de volgende regel van het tekstbestand getoond wordt. Dat gebeurt nu nog niet. Daarvoor moeten we eerst nog iets invoeren.

Dubbelklik op de button bVolgenderegel. En voer onder procedure TForm1.cmdVolgenderegelClick het volgende in:

procedure TForm1.cmdVolgenderegelClick(Sender: TObject);
var regel: String;
begin
      readln(f, regel);
      memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
      aantalregels := aantalregels + 1;
      imgAfdruk.Canvas.TextOut(0,(aantalregels-1)*15,regel);
end;

end;

De opdracht readln(f, regel); heeft tot gevolg dat de volgende regel van het tekstbestand wordt gelezen, en aan de variabele "regel" wordt toegekend.
De computer houdt bij tot hoever hij is gevorderd met het inlezen, en elke keer als hij de opdracht readln(f, regel); tegenkomt leest hij de regel, die dan aan de beurt is, in en de inhoud van die regel wordt dan aan de variabele "regel" toegekend.

Laat het programma nu weer lopen, voer als bestandsnaam PROEF in, en als je geen fouten hebt gemaakt dan wordt de eerste regel van dat tekstbestand getoond in het linker tekstvenster en ook in de rechter imagebox.
Als je daarna op "Lees volgende regel" klikt dan wordt de volgende regel getoond in het linker tekstvenster, en ook in de rechter imagebox.
Klik maar een aantal keren achterelkaar op die button.

De opdracht memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel; heeft tot gevolg dat de volgende regel steeds wordt afgedrukt, maar dat ook de vorige regels te zien zijn.
Als de opdracht memoAfdruk.text := regel; zou zijn, dan zou je steeds alleen de laatste regel zien.
En als de opdracht memoAfdruk.text := memoAfdruk.text + regel; zou zijn, dan zou de nieuwe regel steeds aan het vorige worden vastgeplakt, en dan zou je wel alle regels zien maar niet onder elkaar!
Ze zouden dan achter elkaar komen, op één hele lange regel.

Dan wordt de inhoud van "regel" er aan vastgeplakt!
Maar nu wordt de code chr(13) aan memoAfdruk.text, dus de tekst die er al is, vastgeplakt.
Dat is de code om er voor te zorgen dat de cursor naar de volgende regel gaat.
Dan wordt de code chr(10) er ook nog aan vastgeplakt.
Dat is de code om er voor te zorgen dat de cursor naar het begin van de regel gaat.
En dan wordt de nieuwe regel er aan vast geplakt, zodat de nieuwe regel steeds onder de vorige komt.

De opdracht imgAfdruk.Canvas.TextOut(0,(aantalregels-1)*15,regel); heeft tot gevolg dat de volgende regel steeds onder de vorige wordt afgedrukt.
Als opdracht imgAfdruk.Canvas.TextOut(0,0,regel); zou zijn dan zou de nieuwe regel steeds bovenaan worden afgedrukt, over de vorige heen. En dan zou je de vorige niet meer zien.
Daarom moet het aantal ingelezen regels worden bijgehouden, en als je voor de hoogte van een regel 15 pixels rekent dan moet de plaats van de laatste regel steeds (aantalregels - 1)*15 pixels onder de bovenkantlijn zijn.

En het aantal ingelezen regels moet wel worden bijgehouden, daarom staat er in de programmaregel erboven:
aantalregels := aantalregels + 1;
En verder moet in de procedure voor het inlezen van het begin (dus in procedure TForm1.cmdLeesClick(Sender: TObject);) worden toegevoegd: aantalregels := 1;
En natuurlijk moet de variabele aantalregels ook worden gedeclareerd. Het moet een globale variabele worden, omdat hij in verschillende procedures wordt gebruikt.
Dus boven de regel met implementation komt:
(het eerste regels staan er al)

var
      Form1: TForm1;
      // declaratie van de file
      f:textFile;
      aantalregels: integer;

Voer verder nog bij de button "Sluit af" het volgende in :

procedure TForm1.cmdSluitafClick(Sender: TObject);
begin
      Closefile(f);
end;

Door de opdracht CloseFile(f) wordt het bestand "afgesloten", er kan daarna niets meer uit het bestand worden gelezen.

  4.5 Herhalingen, een aantal regels tegelijk inlezen.

In de vorige paragraaf kon je alle regels laten inlezen, maar voor elke regel moest je weer op de button "Lees volgende regel" klikken.
Dat kan simpeler, want je hebt in Delphi dezelfde opdrachten als in Pascal om iets te laten herhalen.
Als je de volgende programmaregels invoert:

For i := 1 to 20 do
begin
...................................
...................................
end;

dan worden de opdrachten op de stippeltjes 20 keer uitgevoerd, en i doorloopt daarbij achtereenvolgens de waarden 1 tot en met 20

Dat kun je gebruiken als je precies weet hoe vaak het moet gebeuren.
Net als in Pascal heb je ook in Visual Basic opdrachten vergelijkbaar met While en met Repeat.

Als je de volgende programmaregels invoert:

WHILE (xxxxxxxxxxxxxx) do
begin
...................................
...................................
end;

dan worden de opdrachten op de stippeltjes net zo lang uitgevoerd als de voorwaarde op xxxxxxxxxxxxxx geldt.
Er wordt dus pas gestopt als de voorwaarde op xxxxxxxxxxxxxx niet meer geldt.

Als je de volgende programmaregels invoert:

REPEAT
begin
...................................
...................................
UNTIL (xxxxxxxxxxxxxx);

dan worden de opdrachten op de stippeltjes net zo lang uitgevoerd tot de voorwaarde op xxxxxxxxxxxxxx niet meer geldt.

We gaan het programma uit de vorige paragraaf wat aanpassen.
Verwijder eerst het label bVolgenderegel van het formulier, en de bijbehorende programmaregels.
Voer bij de button cmdLees de volgende code onder Click in (verwijder eerst de regels die er al stonden) :

procedure TForm1.cmdLeesClick(Sender: TObject);

// declaratie van de variabele "naambestand" waarin de naam
// van het bestand wordt vastgelegd en van
// de variabele "regel" waarin de inhoud van
// een ingelezen regel wordt vastgelegd.

var bestandsnaam, regel: String;
// declaratie van de teller i
      i: integer;
begin
If (txtBestand.Text <> '') Then
begin
      // haal de naam van het bestand uit de memobox txtBestand
      bestandsnaam := txtBestand.Text + '.txt';
      // het bestand met de ingevoerde naam wordt geopend
      assignFile(f,bestandsnaam);
      // de leeswijzer wordt aan het begin van het bestand gezet
      reset(f);
      // de labels lblBestand en cmdLees en de memobox
      // txtBestand moeten nu verdwijnen

      lblBestand.Visible := False;
      txtBestand.Visible := False;
      cmdLees.Visible := False;
      // de memobox wordt eerst leeggemaakt
      memoAfdruk.text := '';
      // de imagebox wordt leeggemaakt
      imgAfdruk.Canvas.FillRect(Rect(0,0, imgAfdruk.Width, imgAfdruk.Height) );
      // de eerste 10 regels worden ingelezen
      // en afgedrukt in de memobox en in de imagebox
      for i := 1 to 10 do
      begin
            readln(f, regel);
            memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
            imgAfdruk.Canvas.TextOut(0,(i-1)*15,regel);
      end;
end;

end;

Laat het programma nu lopen, voer als bestandsnaam PROEF in.
Als het goed gaat dan worden de eerste tien regels van dat tekstbestand getoond in beide vensters. (natuurlijk moeten er wel tien regels in zitten, anders krijg je een foutmelding)

  4.6 While not end of file

We willen natuurlijk graag dat alle regels van het tekstbestand worden ingelezen en getoond.
Maar hoe kun je dat nu voor elkaar krijgen als je niet weet hoeveel regels er zijn ?
Dan moet de opdracht om een regel in te lezen worden herhaald, net zo lang tot het einde van het tekstbestand is bereikt.
Dat gebeurt door de regel : while not eof(f) do
(eof is de afkorting van end-of-file)
Dit betekent dat de computer doorgaat zolang nog niet het einde van het bestand bereikt is.
Elke keer wordt een nieuwe regel ingelezen, en vastgelegd in de variabele "regel".
Closefile(f); heeft tot gevolg dat het bestand wordt afgesloten, vanaf dat moment kan er niet meer uit dat bestand worden gelezen.

We gaan het programma uit de vorige paragraaf voor de laatste keer aanpassen.
Verwijder het label cmdSluitaf van het formulier, en de bijbehorende programmaregels.
Voer bij de button cmdLees de volgende code onder Click in (verwijder eerst de regels die er al stonden) :

procedure TForm1.cmdLeesClick(Sender: TObject);

// declaratie van de variabele "naambestand" waarin de naam
// van het bestand wordt vastgelegd en van
// de variabele "regel" waarin de inhoud van
// een ingelezen regel wordt vastgelegd.

var bestandsnaam, regel: String;
// declaratie van de teller i
      i: integer;
begin
If (txtBestand.Text <> '') Then
begin
      // haal de naam van het bestand uit de memobox txtBestand
      bestandsnaam := txtBestand.Text + '.txt';
      // het bestand met de ingevoerde naam wordt geopend
      assignFile(f,bestandsnaam);
      // de leeswijzer wordt aan het begin van het bestand gezet
      reset(f);
      // de labels lblBestand en cmdLees en de memobox
      // txtBestand moeten nu verdwijnen

      lblBestand.Visible := False;
      txtBestand.Visible := False;
      cmdLees.Visible := False;
      // de memobox wordt eerst leeggemaakt
      memoAfdruk.text := '';
      // de imagebox wordt leeggemaakt
      imgAfdruk.Canvas.FillRect(Rect(0,0, imgAfdruk.Width, imgAfdruk.Height) );
      // alle regels worden ingelezen
      // en afgedrukt in de memobox en de eerste 10 in de imagebox
      while not eof(f) do
      begin
            readln(f, regel);
            memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
            if (i<10) then imgAfdruk.Canvas.TextOut(0,(i-1)*15,regel);
      end;
end;

end;

Laat het programma nu lopen, voer als bestandsnaam PROEF in.
Als het goed gaat dan worden alle regels van dat tekstbestand getoond in beide vensters.

  4.7. Fouten opvangen.

Normaal is het zo, dat als er een fout optreedt in een programma, het programma stopt, en er verschijnt een foutmelding.
Maar je kunt een foutenafhandeling programmeren, zodat het programma ondanks eventuele fouten toch kan blijft draaien.
Als een programma loopt, en er gaat iets fout, dan zal Delphi een zogenaamde uitzondering genereren.
Deze uitzondering kan in de code van het programma worden opgelost, maar je zult dat wel zelf moeten programmeren.

De volgende codewoorden kun je gebruiken bij het foutafhandelingssysteem :

codewoordbetekenis
trybevat de code die uitgevoerd moet worden, maar waarin eventueel een fout op kan treden
exceptgeeft aan wat er moet gebeuren als er een fout optreedt in de code bij try
finallygeeft aan wat er, fout of geen fout, absoluut uitgevoerd moet worden
raisegeeft de mogelijkheid om zelf een fout te genereren

Het ziet er als volgt uit:

try
  // de code die uitgevoerd moet worden
except
  on exception do
// de code die uitgevoerd moet worden als er een fout optreedt
end;

Als de code in het try-gedeelte geen fout genereert zal de code in het except-gedeelte worden overgeslagen.
Treedt er wel een fout op in het try-gedeelte dan zal het programma verder gaan met het except-gedeelte, en die code kan afhankelijk zijn van de opgetreden fout (elke fout heeft een foutcode, exception genaamd) .

Bij het inlezen van een bestand, bij het programma van Delphi 4.3 , kan er een fout optreden als er een verkeerde bestandsnaam wordt ingevoerd. Als je er voor wilt zorgen dat het programma niet crasht, als dat gebeurt, dan kun je de code als volgt aanpassen: (de zwartgekleurde regels zijn toegevoegd)

procedure TForm1.cmdMaakbestandClick(Sender: TObject);

var bestandsnaam: String;
      // declaratie van de file boven implementation, als globale variabele
begin
If (txtBestand.Text <> '') Then
begin
      bestandsnaam := txtBestand.Text + '.txt';
      // het bestand met de ingevoerde naam wordt aangemaakt
      try
      begin
            assignFile(f,bestandsnaam);
            // de schrijfwijzer wordt aan het begin van het bestand gezet
            REWRITE(f);
            lblBestand.Visible := False;
            txtBestand.Visible := False;
            cmdMaakbestand.Visible := False;
            txtRegel.Visible := True;
            cmdVoegtoe.Visible := True;
            cmdSluitaf.Visible := True;
      end
      except
      on EInOutError do
      begin
            ShowMessage ('Bestand niet gevonden');
            exit;
      end;
end;
end;

end;

In de ontwerpfase wordt er trouwens niet op deze code gereageerd, je moet het gecompileerde programma (een exe-file) starten zonder Delphi en dan werkt het.
De foutcode (hier: EInOutError) kun je gemakkelijk ontdekken: als je het programma laat lopen en je voert een verkeerde bestandsnaam in, dan verschijnt er een foutmelding met de betreffende code.



Bij het programma van Delphi H1, kan er een fout optreden als er geen getal maar een letter of helemaal niets wordt ingevoerd. Als je er voor wilt zorgen dat het programma niet crasht, als dat gebeurt, dan kun je de code als volgt aanpassen: (de zwartgekleurde regels zijn toegevoegd)

procedure TForm1.Button1Click(Sender: TObject);

var g1,g2, s, v, p: integer;
      q: real;

begin
try
begin
      g1 := StrToInt(Edit1.text);
      g2 := StrToInt(Edit2.text);
      s := g1 + g2;
      v := g1 - g2;
      p := g1 * g2;
      if (g2<>0) then q := g1 / g2;
      Edit3.text := IntToStr(s);
      Edit4.text := IntToStr(v);
      Edit5.text := IntToStr(p);
      If (g2<>0) then
            Edit6.text := FloatToStr(q)
      else
            Edit6.text := 'kan niet!';
      end;
end
except
on EInOutError do
begin
      ShowMessage ('Bestand niet gevonden');
      exit;
end;

Ook bij het programma van Delphi H2 kan er zo'n fout optreden. Je kunt dat op dezelfde manier aanpassen.

  4.8. Een bestand uitkiezen m.b.v. een Open-dialoogbox.

In het programma van 4.3 t/m 4.7 is een bestand geopend, nadat de naam van het bestand in ingetypt in een editbox.
Het is ook mogelijk de naam van het bestand uit te kiezen in een lijst, in een verkenner-achtig venster.
Zo'n venster wordt een OpenDialoog-venster genoemd in Delphi.

We veranderen het vorige programma zo, dat het bestand in zo'n OpenDialoog-venster uitgekozen kan worden.
Het formulier veranderen we zoals hiernaast.
Zet er een OpenDialoog-venster op, door in de toolbox te klikken op TOpenDialog, en dan in het formulier te slepen met de muis.
Waar je het plaatst op het formulier maakt niet uit, want je ziet het toch niet op het formulier.
Pas als het OpenDialoog-venster in de code wordt aangeroepen verschijnt er zo'n venster, maar dan als een apart venster.

Het OpenDialoog-venster ziet er dan als volgt uit:



Als je klikt op de Open-en_lees-button dan is het de bedoeling dat het OpenDialoog-venster verschijnt.
Dat programmeer je dan als volgt: (in de commentaarregels zie je betekenis van de code)

procedure TForm1.cmdLeesClick(Sender: TObject);
var bestandsnaam, regel: String;
      i: integer;
      // declareer de OpenDialog variabele
      openDialog : TOpenDialog;
begin
      // laat het OpenDialoog-venster verschijnen
      openDialog := TOpenDialog.Create(self);
      // zorg er voor dat de actieve map de startmap van
      // het OpenDialoog-venster wordt
      openDialog.InitialDir := GetCurrentDir;
      // Zorg er voor dat alleen bestaande files kunnen worden geopend
      openDialog.Options := [ofFileMustExist];
      // Zorg er voor dat alleen txt-files worden getoond
      openDialog.Filter := 'text files|*.txt';
      // Als er op de naam van een bestand geklikt is, doe dan het volgende:
      if (openDialog.Execute) then
            // geef de geheugenruimte voor het OpenDialoog-venster weer vrij
            openDialog.Free;
            // leg het gekozen bestand vast in een variabele
            bestandsnaam := openDialog.FileName;
            // het bestand met de ingevoerde naam wordt opgezocht
            begin
                  assignFile(f,bestandsnaam);
                  // de leeswijzer wordt aan het begin van het bestand gezet
                  reset(f);
                  memoAfdruk.text := '';
                  while not eof(f) do
                  begin
                        readln(f, regel);
                        memoAfdruk.text := memoAfdruk.text + chr(13) + chr(10) + regel;
                        aantalregels := aantalregels + 1;
                  end;
            end;
end;

  4.9 Opdrachten

Opgaven.
Maak nu opgave 4 van de oefenopgaven van delphi