Lazarus/Computer-Mathematik und Lazarus/Die Unit LazIOStuff: Unterschied zwischen den Seiten

Aus ZUM-Unterrichten
< Lazarus(Unterschied zwischen Seiten)
(formatiert)
Markierung: 2017-Quelltext-Bearbeitung
 
(formatiert)
Markierung: 2017-Quelltext-Bearbeitung
 
Zeile 1: Zeile 1:
"Computer" heißt wörtlich übersetzt "Rechner" und deshalb wäre es ja jetzt auch Zeit, ein Programm auch einmal etwas ausrechnen zu lassen. Denn Rechnen ist nicht nur etwas für Mathematik-Programme (die manchen von uns vielleicht nur wenig interessieren) sondern vor allem auch etwas, was für Computerspiele gebraucht wird. Das merkt man schon daran, dass viele neue Computerspiele nach immer schnellerer Computer-Hardware und Prozessor-Leistung verlangen.
== Wozu die Unit LazIOStuff ==


<tt>LazIOStuff</tt> ist eine Lazarus-Unit, die eine Reihe von Befehlen zur vereinfachten Ein- und Ausgabe zur Verfügung stellt. Man kann sich fragen, weshalb man überhaupt eine solche Unit schreibt, wo doch Lazarus von sich aus doch schon jede Menge Möglichkeiten zur Ein- und Ausgabe von Werten hat. Und weshalb man innerhalb eines Online-Lehrbuchs diese Unit benutzt.


Zum Rechnen muss das Programm drei Dinge tun:
Der Hauptgrund besteht darin, dass es beim Lernen einer Programmiersprache angenehm ist, wenn man sich auf die wesentlichen Dinge konzentrieren kann. Vereinfachte Befehle für Ein- und Ausgabe sollen genau dabei helfen. So haben wir z.B. in den vergangenen Kapiteln gesehen, dass wir immer wieder den Inhalt von Edit-Feldern zu Integer- oder Real-Zahlen übersetzen mussten. In den folgenden Kapiteln wollen wir Ergebnisse in Memo-Felder ausgeben, das sind Komponenten mit mehreren Textzeilen.  
*Die Zahlen, die verrechnet werden müssen, müssen eingelesen werden (das machen wir jetzt zunächst über die Tastatur; einlesen kann man Werte natürlich auch über die Maus, den Joystick oder Lenkrad und Gaspedal für Autorennspiele).
Das alles würde auch relativ leicht in Lazarus direkt funktionieren, jedoch würde der Programmcode etwas unübersichtlich, und das kann dem Lernen dann doch abträglich sein.
*Die Zahlen müssen zu einem Ergebnis verrechnet werden.
*Das Ergebnis der Verrechnung muss auf der Benutzeroberfläche ausgegeben werden.


== Arbeiten mit eigenen Variablen ==
== Download und Einbinden ==
Die zugehörige Datei kann hier heruntergeladen werden [http://sourceforge.net/projects/laziostuff/files/laziostuff.pas/download laziostuff.pas]. Die Pascal-Datei muss in das Verzeichnis kopiert werden, in der sich das Lazarus-Projekt befindet, in das es eingebunden werden soll. Das Einbinden selbst erfolgt durch Hinzufügen von <tt>LazIOStuff</tt> in die Zeile <tt>uses ...</tt>


Bisher haben wir nur die Eigenschaften von bestimmten Komponenten geändert bzw. Dinge darin gespeichert, etwa die Beschriftung eines Buttons. Bei komplizierteren Programmen müssen wir aber auch andere Dinge speichern, Dinge die nicht unbedingt jeder gleich sehen muss.
Hierfür gibt es so selbst definierte Variablen.


Jede Variable hat drei wichtige Punkte:
== Die von LazIOStuff bereitgestellten Befehle ==
 
* '''Name''': Jede Variable hat einen eindeutigen Namen, über den sie im Programm angesprochen werden kann.
* '''Typ''': Wie schon bei den Eigenschaften von Komponenten haben auch Variablen verschiedene Typen: ganze Zahlen (integer), reelle Zahlen (real oder double), Zeichenketten (string) usw.
* '''Wert''': In der Variablen gespeichert ist zu jeder Zeit ein ganz bestimmter Wert. Bei einer Variable vom Typ integer könnte das z.B. die Zahl 42 sein.
 
 
Um dem Computer mitzuteilen, dass es eine Variable <tt>zahl</tt> vom Typ <tt>integer</tt> geben soll, muss man die Variable ''deklarieren''.  Die Liste der Variablen eines Programms findet sich hinter dem Stichwort <tt>var</tt> im Programm. Dort ist in unserem Fall bereits die Variable Form1 deklariert. Dies ergänzen wir nun um unsere eigene Variable <tt>zahl</tt>
 
<source highlight="2" lang="pascal">
var Form1 : TForm1;
    zahl : integer;
</source>
 
Wie bei den Eigenschaften auch wird den Variablen im eigentlichen Programmtext zwischen <tt>begin</tt> und <tt>end;</tt> ein Wert über den ":="-Operator zugewiesen, etwa
<source lang="pascal">
zahl:=42;
</source>
 
Ein anschauliches Bild für die Variablen in einem Computerprogramm ist ein Schubladenschrank in der Küche. Der '''Wert''' einer Variable entspräche Inhalt einer solchen Schublade, der '''Name''' wäre etwa ein Etikett auf der Schublade. Um den Vergleich -- wenn auch etwas hinkend -- weiterzuführen, könnte der '''Typ''' der Variablen soetwas wie ein Schubladeneinsatz sein. Es gibt solche Einsätze für Dessertlöffel, aber z.B. auch für Münzgeld.
 
 
=== Einlesen von Integer-Variablen ===
 
Die Anweisung <tt>zahl:=42;</tt> weist der Variablen einen festen Wert, hier die 42 zu. Häufig braucht man jedoch Variablen, deren Wert vom Benutzer während der Laufzeit des Programms eingegeben werden, etwa über eine TEdit-Komponente. Gibt ein Benutzer über eine solche Kompoente eine Zahl ein, steht sie zunächst als Zeichenkette in der Eigenschaft <tt>Text</tt>. Aus dieser Zeichenkette z.B. in <tt>Edit1.Text</tt> muss jetzt eine "richtige" Zahl (z.B. vom Typ <tt>integer</tt>) werden.
 
Das besorgt der Befehl <tt>StrToInt</tt>:
<source lang="pascal">
a:=StrToInt(Edit1.Text);
</source>
 
Diese Zeile sorgt dafür, dass der Integer-Variablen <tt>a</tt> der Wert zugewiesen wird, die der Benutzer in das Edit-Feld <tt>Edit1</tt> geschrieben hat.
 
=== Rechnen mit Integer-Variablen ===
Nehmen wir an, wir hätten drei Integer-Variablen, <tt>a</tt>,<tt>b</tt> und <tt>c</tt>. Das Programm soll nun die Summe der Werte in <tt>a</tt> und <tt>b</tt> ausrechnen; das Ergebnis soll in der Variablen <tt>c</tt> gespeichert werden.
 
Dies erreicht man wieder mit einem Zuweisungsbefehl mit dem stilisierten Pfeil nach links:
<source lang="pascal">
c := a+b;
</source>
 
Natürlich gibt es neben der Addition von Integer-Zahlen auch andere Rechenoperationen:


{| class ="wikitable toptextcells"  
{| class ="wikitable toptextcells"  
! Rechenoperation
! Befehl
! Rechenzeichen <br />in der Sprache Pascal
! Bedeutung
! Beispiel
|-  
|-  
| Addition || <nowiki>+</nowiki> || c:=a+b;
| WriteTo(Komponente, Wert, [Gesamtanzahl Zeichen, Nachkommastellen]) || Schreibt einen Wert (vom Typ String, Integer oder Double) in eine Komponente.<br /> Das kann entweder eine Edit-Komponente oder eine mehrzeilige Memo-Komponente sein. <br />Bei Edit-Komponenten wird der darin befindliche Inhalt einfach ersetzt, bei Memo-Komponenten jedoch hinter den bisherigen Inhalt angehängt. <br/> Bei Integer-Werten kann zusätzlich angegeben werden, wie viele Zeichen die Ausgabe insgesamt haben soll (rechtsbündige Zahlen). <br/>  Bei Double-Zahlen kann man zusätzlich dazu wiederum noch einstellen, mit wie vielen Nachkommastellen die Zahl angezeigt wird.
|-  
|-  
| Subtraktion || <nowiki>-</nowiki> || c:=a-b;
| WriteLnTo(Komponente, Wert, [Gesamtanzahl Zeichen, Nachkommastellen]) || Funktioniert ähnlich wie WriteTo, mit einem wesentlichen Unterschied: <br/> Diese Funktion bezieht sich ausschließlich auf die mehrzeiligen Memo-Komponenten. <br/>Nach der Ausgabe verursacht sie gezielt einen Zeilenumbruch.<br/> WriteLnTo kann man auch ganz ohne Klammern verwenden; dann erzeugt es einfach nur einen Zeilenumbruch.
|-  
|-  
| Multiplikation || <nowiki>*</nowiki> || c:=a*b;
| ReadFrom(Edit-Komponente, Wert) || Liest aus einer Edit-Komponente einen Wert (entsprechend des Datentyps) aus. Möglich sind Zeichenketten (Strings), Integer- und Double-Werte.
|-  
|-  
| (ganzzahlige) Division|| <nowiki>div</nowiki> || c:=a div b;
| Clear(Komponente) ||Löscht den Inhalt der entsprechenden Komponente.
|-  
|-  
| Rest der (ganzzahligen) Division|| <nowiki>mod</nowiki> || c:=a mod b;
|}
|}


Die ganzzahlige Division ist die Division, die die meisten von uns aus der Grundschule kennen:
Das folgende Beispiel demonstriert die verschiedenen Befehle der Unit LazIOStuff und benötigt die Komponenten <tt>Button1, Edit1 und Memo1</tt>.
 
<math>34 : 5 = 6 \text{ Rest } 4</math>
 
Den Wert "6" würde dann die Rechenoperation <tt>34 div 5</tt> liefern, den Wert "4" die Operation <tt>34 mod 5</tt>.
 
=== Ausgabe von Integer-Variablen ===
 
Bisher steht das Ergebnis nur in der Variable <tt>c</tt>. Der Benutzer des Programms sieht davon gar nichts. Der Wert muss noch irgendwie auf der Oberfläche erscheinen. Eine Möglichkeit dazu wäre, die Zahl in ein weiteres Edit-Feld zu schreiben:
 
<source lang="pascal">
Edit3.Text:=IntToStr(c);
</source>
 
Hintergrund: Der Inhalt von Edit-Feldern sind Zeichenketten (engl.: string). Damit eine Integer-Variable in einem Edit-Feld angezeigt werden kann, muss sie in einen solchen String umgewandelt werden. Das erledigt der Befehl <tt>IntToStr(...)</tt>.
 
=== Das ganze Programm zum Rechnen mit Integer-Zahlen ===
Das folgende Programm funktioniert, wenn es auf der Oberfläche die Komponenten <tt>Edit1</tt>, <tt>Edit2</tt> und <tt>Button1</tt> gibt.
<source  line highlight="28-30,36-45" lang="pascal">
unit zahlen_main;


<source  line highlight="6,24,31-40" lang="pascal">
unit lazio_testumgebung;
{$mode objfpc}{$H+}
{$mode objfpc}{$H+}
interface
interface


uses
uses
   Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls;
   Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls, LazIOStuff;


type
type
   { TForm1 }
   { TForm1 }


Zeile 106: Zeile 42:
     Button1: TButton;
     Button1: TButton;
     Edit1: TEdit;
     Edit1: TEdit;
     Edit2: TEdit;
     Memo1: TMemo;
    Edit3: TEdit;
     procedure Button1Click(Sender: TObject);
     procedure Button1Click(Sender: TObject);
   private
   private
Zeile 113: Zeile 48:
   public
   public
     { public declarations }
     { public declarations }
   end;  
   end;


var
var
   Form1: TForm1;  
   Form1: TForm1;
   a : integer; // wir erfinden eine Zahlen-Variable a
   zahl : integer;
  b : integer;  // wir erfinden eine Zahlen-Variable b
  c : integer;  // wir erfinden eine Zahlen-Variable c


implementation
implementation


{$R *.lfm}
{ TForm1 }
{ TForm1 }


procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
begin
begin
a:=StrToInt(Edit1.Text); // belege die Variablen
ReadFrom(Edit1,zahl);
b:=StrToInt(Edit2.Text); // mit den Inhalten der Edit-Felder
Clear(Memo1);
 
WriteLnTo(Memo1,'Es geht los!');
c:=a+b; // Addiere a und b und weise den Wert der Variable c zu
WriteLnTo(Memo1,zahl);
 
WriteLnTo(Memo1,zahl,10);
Edit3.Text:=IntToStr(c);
WriteLnTo(Memo1,' wurde eingegeben. Und die Hälfte davon ist:');
 
WriteLnTo(Memo1,zahl/2,20,5);
end;
end;
initialization
  {$I zahlen_main.lrs}


end.
end.
</source>
</source>


==Arbeiten mit Reellen Zahlen==
Die Ausgabe in der <tt>Memo1</tt>-Komponente nach Eingabe der Zahl "7" in der Komponente <tt>Edit1</tt> ist:
Das Arbeiten mit reellen Zahlen vom Typ <tt>real</tt> oder <tt>double</tt> funktioniert sehr ähnlich, mit ein paar kleinen Unterschieden. Zunächst einmal muss man statt <tt>integer</tt> natürlich <tt>double</tt> als Typbezeichnung verwenden.
<source lang="pascal">Es geht los!
 
7
Statt <tt>IntToStr</tt> und <tt>StrToInt</tt> werden hier der Befehl <tt>StrToFloat</tt> und der sehr mächtige Formatierungsbefehl <tt>format</tt> verwendet.
        7
 
wurde eingegeben. Und die Hälfte davon ist:
Die Zeile
            3,50000
<source lang="pascal">
Edit3.Text:=format('%5.2f',[c]);
</source>
</source>
sorgt dafür, dass die double-Variable <tt>c</tt> in das Edit-Feld geschrieben wird, dass sie insgesamt 5 Stellen und 2 Nachkommastellen hat.
<source  start=36 line highlight="1-14" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
begin
a:=StrToFloat(Edit1.Text);  // belege die Variablen
b:=StrToFloat(Edit2.Text);  // mit den Inhalten der Edit-Felder
c:=a+b; // Addiere a und b und weise den Wert der Variable c zu
Edit3.Text:=format('%5.2f',[c]);
end;</source>
Weitere Rechenoperationen für reelle Zahlen sind:
{| class ="wikitable toptextcells"
! Rechenoperation
! Rechenzeichen <br />in der Sprache Pascal
|-
| Quadratwurzel-Funktion|| <nowiki>sqrt(x)</nowiki>
|-
| Exponentialfunktion|| <nowiki>exp(x)</nowiki>
|-
| Sinus-Funktion|| <nowiki>sin(x)</nowiki>
|-
| Cosinus-Funktion|| <nowiki>cos(x)</nowiki>
|-
| Tangens|| <nowiki>tan(x)</nowiki>
|-
| Natürlicher Logarithmus|| <nowiki>ln(x)</nowiki>
|-
| Kaufmännisches Runden|| <nowiki>round(x)</nowiki>
|-
| Abrunden auf die nächstkleinere ganze Zahl|| <nowiki>trunc(x)</nowiki>
|}
Neben diesen mathematischen Funktionen gibt es noch jede Menge andere in Lazarus. Um diese jedoch verwenden zu können, muss in der Liste der so genannten Software-Bibliotheken noch die Bibliothek <tt>Math</tt> angegeben werden:
<source lang="pascal">
uses Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls, Math;
</source>
{| class ="wikitable toptextcells"
! Rechenoperation
! Funktion <br />in der Sprache Pascal
|-
| Umkehrfunktionen von trigonometrischen Funktionen || <nowiki>arcsin(x), arccos(x)</nowiki>
|-
| Logarithmus zur Basis 10 || <nowiki>log10(x)</nowiki>
|-
| Logarithmus zur Basis 2 || <nowiki>log2(x)</nowiki>
|-
| Logarithmus zu beliebiger Basis  || <nowiki>logn(basis,x)</nowiki>
|-
| Beliebige Potenz || <nowiki>power(basis,exponent)</nowiki>
|-
| Umrechnung von Bogenmaß nach Gradmaß|| <nowiki>radtodeg(x)</nowiki>
|-
| Umrechnung von Gradmaß nach Bogenmaß|| <nowiki>degtorad(x)</nowiki>
|}
Wichtig zu wissen ist bei den trigonometrischen Funktionen, dass sie immer von Angaben im Bogenmaß (statt 360° also <math> 2\pi</math> ausgehen. Angaben in Gradmaß müssen mit <tt>degtorad(x)</tt> umgerechnet werden.
Welche Funktionen noch alle in "Math" enthalten sind, findet man unter <br />
http://lazarus-ccr.sourceforge.net/docs/rtl/math/


{{Aufgabe|
{{Aufgabe|1=
#'''Wirtschaft: Handwerk hat goldenen Boden'''<br>Malermeister Klecksel muss zur Berechnung des ungefähren Verbrauchs an Farbe nach Angabe von Höhe, Breite und Länge eines Raums wissen <br /> a) Welche Fläche die Wände haben (Fenster spielen erst mal keine Rolle)<br /> b) Welche Fläche die Decke hat (wird manchmal in einer anderen Farbe gestrichen)<br />Entwickle eine geeignete komfortable Software!
#Ein Programm soll zwei Edit-Komponenten haben, eine für den Vornamen und eine für den Nachnamen einer Person. Auf Knopfdruck soll dann in einer Memo-Komponente etwa die Ausgabe <br/> <tt>Herzlich willkommen</tt> <br/> <tt>Donald Duck</tt> <br/> erscheinen. Ein weiterer Knopf soll beim Drücken bewirken, dass das Memo-Feld wieder gesäubert wird.
#'''Wirtschaft: Mehrwertsteuer'''<br>Schreibe ein Programm, das für einen eingegebenen Betrag die Mehrwertsteuer berechnet und außerdem den Betrag zuzüglich Mehrwertsteuer. Den aktuellen Mehrwertsteuersatz findet man wahrscheinlich im Internet. Der Wert sollte kaufmännisch auf zwei Nachkommastellen gerundet sein.
#Schreibe ein Divisionsprogramm, das in zwei Edit-Feldern zwei Zahlen eingibt. In einem Memo-Feld sollen dann das Ergebnis der ganzzahligen Division, der Rest der ganzzahligen Division, der Quotient als Kommazahl (10 Zeichen gesamt, 3 Nachkommastellen) stehen. <br/> Und selbstverständlich soll der Computer vorher prüfen, ob hier nicht durch Null dividiert werden soll. Sollte der Benutzer das versuchen, soll ein Ausgabe im Memo-Feld erscheinen, die den Benutzer auf seinen Fehler aufmerksam macht.}}
#'''Mathematik: Lineare Funktionen'''<br>Eine lineare Funktion hat die Funktionsgleichung <math>f(x)=m \cdot x + n</math>. Schreibe ein Programm, bei dem man m, n und x eingeben kann und den Funktionswert erhält.
#'''Mathematik: Kompliziertere Funktionen'''<br>Schreibe ein Programm, das nach der Eingabe des Wertes für den Wert des Polynoms <math>x^2-8x+5</math> berechnet.
#'''Mathematik: Geradensteigung aus zwei Punkten'''<br>In Klasse 9 lernt man, wie man aus zwei Punkten die Steigung einer Gerade durch diese beiden Punkte berechnet. <br />Schreibe ein Programm für einen Freund aus der 9. Klasse, der seine Hausaufgaben „kontrollieren“ will.<br />Zur Erinnerung: <math>m=\frac{y_2-y_1}{x_2-x_1}</math>
#'''Mathematik: y-Achsenabschnitt aus zwei Punkten'''<br>Erweitere das obige Programm, das aus den zwei gegebenen Punkten auch den y-Achsenabschnitt berechnet.
#'''Mathematik: Nullstellenberechnung'''<br>Eine lineare Funktion hat die Funktionsgleichung <math>f(x)=m \cdot x + n</math>. Schreibe ein Programm, bei dem man m und n eingeben kann und das daraufhin die Nullstelle ausrechnet.
#'''Mathematik: Nullstellen quadratischer Funktionen'''<br>Du kennst die p-q-Formel (oder auch a-b-c-Formel) zum Lösen quadratischer Gleichungen. Schreibe ein Programm, das nach Eingabe von p und q (bzw. a, b und c) die beiden Nullstellen der entsprechenden Funktion berechnet. Versuche einige Eingaben und überlege, ob es nicht Eingaben geben könnte, die Probleme verursachen.
#'''Physik: Pendelhöhe''' <br> Ein Fadenpendel mit einem kleinen Pendelkörper am Ende einer Länge wird um einen bestimmten Winkel (angegeben im Gradmaß) ausgelenkt. Schreibe ein Programm, das nach Eingabe der Pendellänge und des Auslenkwinkels die Höhe des Pendelkörpers über der Ruhelage errechnet.}}


{{Lazarus-Buch}}
{{Lazarus-Buch}}

Version vom 10. August 2019, 06:19 Uhr

Wozu die Unit LazIOStuff

LazIOStuff ist eine Lazarus-Unit, die eine Reihe von Befehlen zur vereinfachten Ein- und Ausgabe zur Verfügung stellt. Man kann sich fragen, weshalb man überhaupt eine solche Unit schreibt, wo doch Lazarus von sich aus doch schon jede Menge Möglichkeiten zur Ein- und Ausgabe von Werten hat. Und weshalb man innerhalb eines Online-Lehrbuchs diese Unit benutzt.

Der Hauptgrund besteht darin, dass es beim Lernen einer Programmiersprache angenehm ist, wenn man sich auf die wesentlichen Dinge konzentrieren kann. Vereinfachte Befehle für Ein- und Ausgabe sollen genau dabei helfen. So haben wir z.B. in den vergangenen Kapiteln gesehen, dass wir immer wieder den Inhalt von Edit-Feldern zu Integer- oder Real-Zahlen übersetzen mussten. In den folgenden Kapiteln wollen wir Ergebnisse in Memo-Felder ausgeben, das sind Komponenten mit mehreren Textzeilen. Das alles würde auch relativ leicht in Lazarus direkt funktionieren, jedoch würde der Programmcode etwas unübersichtlich, und das kann dem Lernen dann doch abträglich sein.

Download und Einbinden

Die zugehörige Datei kann hier heruntergeladen werden laziostuff.pas. Die Pascal-Datei muss in das Verzeichnis kopiert werden, in der sich das Lazarus-Projekt befindet, in das es eingebunden werden soll. Das Einbinden selbst erfolgt durch Hinzufügen von LazIOStuff in die Zeile uses ...


Die von LazIOStuff bereitgestellten Befehle

Befehl Bedeutung
WriteTo(Komponente, Wert, [Gesamtanzahl Zeichen, Nachkommastellen]) Schreibt einen Wert (vom Typ String, Integer oder Double) in eine Komponente.
Das kann entweder eine Edit-Komponente oder eine mehrzeilige Memo-Komponente sein.
Bei Edit-Komponenten wird der darin befindliche Inhalt einfach ersetzt, bei Memo-Komponenten jedoch hinter den bisherigen Inhalt angehängt.
Bei Integer-Werten kann zusätzlich angegeben werden, wie viele Zeichen die Ausgabe insgesamt haben soll (rechtsbündige Zahlen).
Bei Double-Zahlen kann man zusätzlich dazu wiederum noch einstellen, mit wie vielen Nachkommastellen die Zahl angezeigt wird.
WriteLnTo(Komponente, Wert, [Gesamtanzahl Zeichen, Nachkommastellen]) Funktioniert ähnlich wie WriteTo, mit einem wesentlichen Unterschied:
Diese Funktion bezieht sich ausschließlich auf die mehrzeiligen Memo-Komponenten.
Nach der Ausgabe verursacht sie gezielt einen Zeilenumbruch.
WriteLnTo kann man auch ganz ohne Klammern verwenden; dann erzeugt es einfach nur einen Zeilenumbruch.
ReadFrom(Edit-Komponente, Wert) Liest aus einer Edit-Komponente einen Wert (entsprechend des Datentyps) aus. Möglich sind Zeichenketten (Strings), Integer- und Double-Werte.
Clear(Komponente) Löscht den Inhalt der entsprechenden Komponente.

Das folgende Beispiel demonstriert die verschiedenen Befehle der Unit LazIOStuff und benötigt die Komponenten Button1, Edit1 und Memo1.

unit lazio_testumgebung;
{$mode objfpc}{$H+}
interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls, LazIOStuff;

type
  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;
  zahl : integer;

implementation

{$R *.lfm}
{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
begin
ReadFrom(Edit1,zahl);
Clear(Memo1);
WriteLnTo(Memo1,'Es geht los!');
WriteLnTo(Memo1,zahl);
WriteLnTo(Memo1,zahl,10);
WriteLnTo(Memo1,' wurde eingegeben. Und die Hälfte davon ist:');
WriteLnTo(Memo1,zahl/2,20,5);
end;

end.

Die Ausgabe in der Memo1-Komponente nach Eingabe der Zahl "7" in der Komponente Edit1 ist:

Es geht los!
7
         7
 wurde eingegeben. Und die Hälfte davon ist:
             3,50000


Aufgabe
  1. Ein Programm soll zwei Edit-Komponenten haben, eine für den Vornamen und eine für den Nachnamen einer Person. Auf Knopfdruck soll dann in einer Memo-Komponente etwa die Ausgabe
    Herzlich willkommen
    Donald Duck
    erscheinen. Ein weiterer Knopf soll beim Drücken bewirken, dass das Memo-Feld wieder gesäubert wird.
  2. Schreibe ein Divisionsprogramm, das in zwei Edit-Feldern zwei Zahlen eingibt. In einem Memo-Feld sollen dann das Ergebnis der ganzzahligen Division, der Rest der ganzzahligen Division, der Quotient als Kommazahl (10 Zeichen gesamt, 3 Nachkommastellen) stehen.
    Und selbstverständlich soll der Computer vorher prüfen, ob hier nicht durch Null dividiert werden soll. Sollte der Benutzer das versuchen, soll ein Ausgabe im Memo-Feld erscheinen, die den Benutzer auf seinen Fehler aufmerksam macht.