Lazarus/Schleifen und Lazarus/Verzweigungen: Unterschied zwischen den Seiten

Aus ZUM-Unterrichten
< Lazarus(Unterschied zwischen Seiten)
main>Peterdauscher
 
main>Peterdauscher
 
Zeile 1: Zeile 1:
{{Lazarus-Buch}}
{{Lazarus-Buch}}
== Wenn-Dann-Sonst (If-then-else) ==


== Zählschleifen ==
Bisher wurden die Computerprogramme strikt von oben nach unten abgearbeitet. Das ist aber nicht immer wünschenswert. Zum Beispiel kann es sein, dass bestimmte Programmteile nur dann ausgeführt werden, wenn bestimmte Bedingungen auch erfüllt sind. Wir alle kennen z.B. Passwort-Abfragen, bei denen Funktionen eines Programms oder einer Website nur dann funktionieren, wenn man das richtige Passwort angibt.
Mit Hilfe von Alternativen (if-then-else) konnten wir Programme so steuern, dass bestimmte Anweisungen nur unter ganz bestimmten Bedingungen ausgeführt wurden, andernfalls nicht. Allerdings wurde die gleiche Anweisung (bei ein und demselben Knopfdruck) immer nur ein einziges Mal ausgeführt.


Wir starten ein neues Lazarus-Projekt und betrachten ein mehrzeiliges Eingabe-Feld, ein so genanntes Memo-Feld (TMemo). Wir wollen, dass dem Memo-Feld <tt>Memo1</tt> beim Druck auf den Knopf <tt>Button1</tt> jeweils eine Zeile mit de, Wort "Hallo" hinzugefügt wird.
=== Beispiel ===


Dafür ändern wir die Prozedur <tt>TForm1.Button1Click(Sender: TObject); </tt> wie folgt. (Es ist nur die entscheidende Prozedur vermerkt, den Rest kennst Du mittlerweile).
Wir betrachten das einfache Beispiel eines Lazarus-Programms mit zwei Edit-Feldern, <tt>Edit1</tt> und <tt>Edit2</tt> und einem Button <tt>Button1</tt>. Wenn der Button1 gedrückt wird, soll der Computer die Eingabe in <tt>Edit1</tt> überprüfen. Steht darin das richtige Passwort ("geheim"), so soll in <tt>Edit2</tt> angezeigt werden: "Sie sind angemeldet!"


{{kasten_blau|<source  line start="33" highlight="3" lang="pascal">
{{kasten_blau|<source  line highlight="35-39" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
unit passwort;
begin
 
   Memo1.Lines.Add('Hallo');
{$mode objfpc}{$H+}
end;    
 
</source>}}
interface
 
uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls;
 
type
 
  { TForm1 }
 
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
   public
    { public declarations }
  end;


var
  Form1: TForm1;


Bei vielen Dingen ist es jedoch sinnvoll, wenn Dinge mehrfach ausgeführt werden. Nicht umsonst heißt es: "Ein Computer ist unglaublich dumm, aber sehr sehr fleißig". So könnte eine sehr einfache Aufgabe an den Computer lauten, er solle das Wort "Hallo" 10 mal untereinander in das Memo-Feld <tt>Memo1</tt> schreiben.
implementation


Natürlich könnten wir den Befehl <tt>Memo1.Lines.Add('Hallo');</tt> zehn mal untereinander kopieren. Aber das wäre sehr sehr lästige -- und schlimmer noch -- langweilige Arbeit.
{$R *.lfm}
Viel bequemer ist es dagegen, wenn wir dem Computer sagen:


"Es gibt eine Variable <tt>zaehler</tt>. Setze diese Variable zunächst auf 1 und zähle sie dann schrittweise auf 10 hoch. Nach jedem Zählschritt schreibe das Wort "Hallo" in das Memo-Feld." Genau dies tut das folgende Programm.
{ TForm1 }


{{kasten_blau|<source  line start="33" highlight="3-4" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
begin
begin
for zaehler:=1 to 10
  if Edit1.Text='geheim'
do Memo1.Lines.Add('Hallo');
  then Edit2.Text:='Sie sind angemeldet';
end;                    
end;
 
end.
</source>}}
</source>}}


Allerdings musst Du noch bei der Liste der Variablen die Variable <tt>zaehler</tt> als Integer-Variable deklarieren:
Das Programm ist allerdings noch nicht besonders benutzerfreundlich. Gibt der Benutzer z.B. ein falsches Passwort ein, so erhält er gar keine Nachricht. Es passiert einfach nichts.  
<tt>zaehler : integer;</tt>
Wenn Du nicht jedes Mal wieder zur Variablenliste springen willst, kannst Du die Variable auch direkt in der Prozedur vor dem <tt>begin</tt> deklarieren. Dann allerdings kennt Lazarus diese Variable tatsächlich nur innerhalb dieser Prozedur. Beim nächsten Beispiel ist dies so gemacht.


Dieses Beispiel zeigt, wie bei jedem Zählschritt auch mehrere Anweisungen ausgeführt werden können: die muss man hier wieder mit <tt>begin</tt> und <tt>end</tt> zu einem Anweisungsblock gruppieren:  
Das kann man ändern. Im Falle, dass die Eingabe nicht 'geheim' lautet, soll in Edit2 die Bemerkung: 'Falsches Passwort' ausgegeben werden.
{{kasten_blau|<source  line start="33" highlight="5-8" lang="pascal">
{{kasten_blau|<source  line start=35 highlight="1-6" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
begin
begin
for zaehler:=1 to 10
  if Edit1.Text='geheim'
do begin
  then Edit2.Text:='Sie sind angemeldet'
  Memo1.Lines.Add('Hallo');
  else Edit2.Text:='Falsches Passwort';
  Memo1.Lines.Add('=========='); 
end;            
  end;  
end;                    
</source>}}
</source>}}


Und ganz wichtig: Die Variable <tt>zaehler</tt> kann im Programm auch verwendet werden. Zum Beispiel, um die "Hallo-Welt"-Ausrufe durchzunummerieren. Da die Nummer und das "Hallo" durchaus in eine Zeile passen, kann man beide dem "+"-Zeichen verbinden und in ein- und dasselbe "Add" hineinschreiben:
=== Wichtige Anmerkungen ===
* Achtung: vor "else" steht nie ein Semiklon. Das Semikolon beendet einen Befehl; die ganze If-then-else-Konstruktion ist jedoch im Grunde ein einzelner Befehl; das Semikolon steht erst danach.
* Man beachte das Gleichheitszeichen in <tt><nowiki>if Edit1.Text='geheim'</nowiki></tt>. Es ist ein einzelnes Gleichheitszeichen '''ohne Doppelpunkt'''. Es beschreibt auch etwas ganz anderes als eine Wertzuweisung: Es beschreibt einen Bedingung. Es gibt nur zwei Möglichkeiten: Die Bedingung ist erfüllt (wahr, engl. true) oder eben nicht (falsch, engl. false).  
* Wenn Du Dich an das Kapitel [[../Variablen_und_Komponenten]] erinnerst, kamen da Variablen vom Typ <tt>boolean</tt> vor, die genau diese beiden möglichen Werte hatten. Tatsächlich könnte man einer Variable <tt>b</tt> vom Typ <tt>boolean</tt> mit <tt>b:=(Edit1.Text='geheim');</tt> einen Wert zuweisen, je nachdem, ob der Text der richtige war oder nicht.


{{kasten_blau|<source  line start="33" highlight="7" lang="pascal">
== Mehrere Anweisungen zu einem Block gruppieren==
Bisher wird in jedem der beiden Fälle genau eine einzelne Anweisung ausgeführt. Es kann aber leicht sein, dass nur im Fall einer erfüllten (oder auch nicht erfüllten) Bedingung gleich mehrere Anweisungen ausgeführt werden sollen.  Im nächsten Beispiel soll z.B. bei einer falschen Eingabe auf dem Button die Beschriftung zu 'Nochmal versuchen' geändert weden:
{{kasten_blau|<source  line start=36 highlight="1-9" lang="pascal">
procedure TForm1.Button1Click(Sender: TObject);
procedure TForm1.Button1Click(Sender: TObject);
var zaehler : integer;
begin
begin
Memo1.Lines.Clear;
  if Edit1.Text='geheim'
for zaehler:=1 to 10
  then Edit2.Text:='Sie sind angemeldet'
do begin
  else begin
  Memo1.Lines.Add(IntToStr(zaehler)+' Hallo');
      Edit2.Text:='Falsches Passwort';
  Memo1.Lines.Add('===============');
      Button1.Caption:='Nochmal versuchen';
  end;
      end;
end;  
end;                
</source>}}        
</source>}}
Die beiden Anweisungen zum Verändern von <tt>Edit2.Text</tt> und <tt>Button1.Caption</tt> sind durch ein <tt>begin</tt> und ein <tt>end</tt> umrahmt. Manche Leute sprechen von einem '''Programm-Block'''. Natürlich kann auch hinter <tt>then</tt> ein Programm-Block stehen: Aber Vorsicht: Hinter dem <tt>end</tt> steht dann wieder kein Semikolon.


Außerdem sorgt bei diesem Beispiel die Zeile <tt>Memo1.Lines.Clear;</tt> in Zeile 36 dafür, dass das Feld vor dem Beschreiben gesäubert wird und das (vielleicht lästigte) <tt>Memo1</tt> verschwindet.
== Vergleiche von Zahlen ==


== Schleifen mit Eingangsbedingung (while-Schleifen)==
Natürlich kann man nicht nur Zeichenketten miteinander vergleichen, sondern auch Zahlen. Neben der reinen Gleichheit gibt es auch andere Vergleichsoperatoren:
Nehmen wir an, ein (recht phantasieloser) Lehrer gäbe seinen Schüler die Stillarbeit, so viele aufeinanderfolgende Zahlen zu addieren und die Zwischenergebnisse zu notieren, bis die Summe den Wert 1000 erreicht. Schüler Fritz hat sein Netbook im Ranzen und will das Problem mit Lazarus lösen. Das Problem: Er kann jetzt natürlich auf gut Glück ungefähr raten, bis zu welcher Zahl er die Zahlen addieren muss und dies mit einer for-Schleife tun. Aber es muss doch auch eine andere Möglichkeit geben, nämlich, dass der Computer selbst merkt, wenn das Ergebnis erreicht ist. Tatsächlich gibt es diese Möglichkeit.


{{kasten_blau|<source  highlight="5,9" line start="33"  lang="pascal">
{| class ="wikitable toptextcells"  
procedure TForm1.Button1Click(Sender: TObject);
! Vergleichsoperator
var zaehler, summe : integer;
! Bedeutung
begin
|-
Memo1.Lines.Clear;
| <nowiki>=</nowiki> || gleich
zaehler:=0;
|-
summe:=0;
| <nowiki><=</nowiki> || kleiner oder gleich
while summe<1000
|-
do begin
| <nowiki>>=</nowiki> || größer oder gleich
  zaehler:=zaehler+1;
|-
  summe:=summe+zaehler;
| <nowiki><></nowiki> || ungleich
  Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
|}
  end;
end;               
</source>}}


Man erkennt deutliche Unterschiede: Die Schleife, so heißt es in dem Programm, wird so lange wiederholt, solange die Summe noch einen Wert kleiner als 1000 hat. Das Setzen des Zählers auf 0 am Anfang und das Hochzählen in jedem einzelnen Schritt, muss der Programmierer hier selbst übernehmen (Zeilen 37 bzw. 41).


'''Wichtige Anmerkung''':
== Verknüpfung von Bedingungen ==
Angenommen, man würde in Zeile 38 den anfänglichen Wert der Variable <tt>summe</tt> auf 1000 setzen, so würde der Computer sozusagen gar nicht erst mit der Schleife anfangen, sondern alles zwischen <tt>while</tt> und dem <tt>end</tt> der Schleife überspringen. Denn die Schleife soll ja nur solange ausgeführt werden, solange die Bedingung <tt>summe<1000</tt> erfüllt ist. Und das wäre sie in diesem Fall ja von Anfang an nicht. Deshalb spricht man bei der while-Schleife auch von einer Schleife mit Eingangsbedingung.


== Schleifen mit Abbruchbedingung (repeat-until-Schleifen) ==
In einer if-Abfrage können auch Bedingungen abgefragt werden, die aus mehreren Teilbedingungen bestehen, die durch logische Verknüpfungen verbunden sind. Diese Verknüpfungen sind


Anders ist es bei Schleifen mit Abbruchsbedingung. Bei denen wird das Innere der Schleife mindestens einmal durchlaufen. Eine solche Schleife ist in Pascal die so genannte Repeat-Until-Schleife. Unser Problem mit dem Aufsummieren von Zahlen bis zur Summe 1000 könnte mit einer solchen Schleife so aussehen:
{| class ="wikitable toptextcells"
! Vergleichsoperator
! Bedeutung
|-
| Bedingung1 <tt>and</tt> Bedingung2 || Gilt dann und nur dann, wenn beide Bedingungen erfüllt sind.  
|-
| Bedingung1 <tt>or</tt> Bedingung2 || Gilt bereits dann, wenn eine der beiden Bedingungen erfüllt sind, aber auch dann, wenn beide erfüllt sind.
|-  
| Bedingung1 <tt>xor</tt> Bedingung2 || Gilt dann und nur dann, wenn genau eine der beiden Bedingungen erfüllt sind, aber nicht dann, wenn keine oder beide erfüllt sind.
|-  
| <tt>not</tt> Bedingung|| Gilt dann, wenn die Bedingung selbst genau '''nicht''' gilt.
|}


{{kasten_blau|<source highlight="6,10" line start="33" lang="pascal">procedure TForm1.Button1Click(Sender: TObject);
Es ist häufig sinnvoll, die einzelnen Bedingungen selbst in Klammern zu setzen.
begin
Memo1.Lines.Clear;
zaehler:=0;
summe:=0;
  repeat
  zaehler:=zaehler+1;
  summe:=summe+zaehler;
  Memo1.Lines.Add(IntToStr(zaehler)+':'+IntToStr(summe));
  until summe>1000;
end;   
</source>}}


Das Programm verhält sich haargenau wie das Programm mit der While-Schleife. Solange man nicht die Summe vorher größer oder gleich 1000 wählt. Würde man das tun, würde zumindest ein Summations- und Schreibschritt ausgeführt und erst dann die Schleife abgebrochen.
==Aufgaben==
#'''Abgestufte Höflichkeit'''<br>In dem Edit-Feld <tt>Edit</tt> soll ein Vorname eingegeben werden. Wenn es Dein eigener ist, dann soll der Computer gehorsam mit "Willkommen mein Herr und Meister" begrüßen; ansonsten (etwas unfreundicher) mit "Was willst Du?".
#'''Volljährigkeit'''<br>Ist der Bürger 18 Jahre und älter, dann ist er volljährig. Ein Computerprogramm soll auf Knopfdruck das Alter eines Bürgers aus dem Feld <tt>Edit1</tt> einlesen und in das Feld <tt>Edit2</tt> ausgeben, ob er volljährig ist.
#'''Intervall-Prüfung'''<br>Eine Zahl wird in einer Edit-Komponente eingegeben. Das Programm soll entscheiden, ob diese Zahl zwischen 10 und 20 liegt.
#'''Gefährliche Knöpfe'''<br>Manche Aktionen bei Computerprogrammen sind so risikoreich, dass der Benutzer nicht einmal, sondern dreimal auf den entsprechenden Button klicken sollte, bevor sie ausgeführt werden. Schreibe ein Programm mit dem Knopf "Selbstzerstörung starten", den man drei mal drücken muss, bevor in einem Label der Text: "Selbstzerstörung ist aktiviert" erscheint und der Button selbst unsichtbar wird.
#'''pq-Formel allgemein'''<br>Eine quadratische Funktion sei definiert als <math>f(x)=x^2+px+q</math>. Die so genannte pq-Formel gibt an, welche Nullstellen eine solche Funktion hat: <br/> <math>x_{1/2}=-\frac{p}{2}\pm\sqrt{\frac{p^2}{4}-q}</math> <br/> Ein Programm soll geschrieben werden, das die Werte p und q aus zwei Edit-Komponenten ausliest und in zwei weitere Edit-Komponenten die Werte der beiden Nullstellen schreibt. Vorausgesetzt natürlich, dass die Funktion überhaupt (reelle) Nullstellen hat (was nicht immer der Fall ist).


==Aufgaben==
#Ändere das einfache Zählprogramm mit for-Schleife so ab, dass man in einem Edit-Feld angeben kann, bis zu welcher Zahl der Computer zählen soll.
#Karin bekommt 100 Euro geschenkt. Sie legt sie auf der Bank an mit einem Zinssatz von <nowiki>2.3%</nowiki> (Jahreszins). Ein Programm soll ihr sagen, nach wievielen Jahren sich die Summe verdoppelt hat (oder mehr).
#Zeichne in eine Image-Komponente ein Gitter mit Kästchen. Die horizontalen und vertikalen Linien sollen jeweils einen Abstand von 20 Pixeln voneinander haben.
#Eine Image-Komponente soll von unten nach oben mit einem Farbverlauf von dunkelgrau nach hellgrau ausgefüllt werden.
#Versuche, eine Sinuskurve auf dem Bildschirm darzustellen.
#Bei radioaktiven Stoffen spricht man von der Halbwertszeit, das ist die Zeit, nach der ein Stoff nur noch halb soviel strahlt. Schreibe ein Programm, das die Halbwertszeit (in Jahren) vom Benutzer erfragt und dann ausrechnet, nach wievielen Jahren die Strahlung auf ein Hundertstel zurückgegangen ist.
#In grauer Vorzeit (bis zur Erfindung des Taschenrechners) hatte man sogenannte Logarithmentafeln, in denen die Werte der Logarithmusfunktion tabelliert waren, also eine Tabelle mit x und ln x als Spalten. Schreibe ein Programm, das eine solche Tafel ausdruckt (für x-Werte 0.01, 0.02 . . . 1.00).
#Der Mathematiker Leibnitz fand eine Methode, die Zahl π näherungsweise zu berechnen.<br/> Es gilt: <math>\frac{\pi}{4}=1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}+\ldots </math><br/> Schreibe ein Programm, das diesen langen Ausdruck bis zum Summanden <math>\frac{1}{401}</math> ausrechnet. Vergleiche die Zahl mit dem Ergebnis Deines Taschenrechners.
#Die Fakultät einer Zahl n (geschrieben als n!) ist definiert als <math> n!= 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n</math> <br /> Schreibe ein Programm, das nach Eingabe einer Zahl n die Fakultät ausrechnet. Was passiert bei großen Werten für n?
#Zwei Würfel werden geworfen. Schreibe ein Programm, dass alle Möglichkeiten ausgibt, wie die beiden Augenzahlen aussehen können (also etwa: (1,1), (1,2), (1,3), ... (6,6)).


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

Version vom 9. Februar 2014, 11:40 Uhr

Lazarus Logo (new).png

Lazarus-Buch

Wenn-Dann-Sonst (If-then-else)

Bisher wurden die Computerprogramme strikt von oben nach unten abgearbeitet. Das ist aber nicht immer wünschenswert. Zum Beispiel kann es sein, dass bestimmte Programmteile nur dann ausgeführt werden, wenn bestimmte Bedingungen auch erfüllt sind. Wir alle kennen z.B. Passwort-Abfragen, bei denen Funktionen eines Programms oder einer Website nur dann funktionieren, wenn man das richtige Passwort angibt.

Beispiel

Wir betrachten das einfache Beispiel eines Lazarus-Programms mit zwei Edit-Feldern, Edit1 und Edit2 und einem Button Button1. Wenn der Button1 gedrückt wird, soll der Computer die Eingabe in Edit1 überprüfen. Steht darin das richtige Passwort ("geheim"), so soll in Edit2 angezeigt werden: "Sie sind angemeldet!"

Vorlage:Kasten blau

Das Programm ist allerdings noch nicht besonders benutzerfreundlich. Gibt der Benutzer z.B. ein falsches Passwort ein, so erhält er gar keine Nachricht. Es passiert einfach nichts.

Das kann man ändern. Im Falle, dass die Eingabe nicht 'geheim' lautet, soll in Edit2 die Bemerkung: 'Falsches Passwort' ausgegeben werden. Vorlage:Kasten blau

Wichtige Anmerkungen

  • Achtung: vor "else" steht nie ein Semiklon. Das Semikolon beendet einen Befehl; die ganze If-then-else-Konstruktion ist jedoch im Grunde ein einzelner Befehl; das Semikolon steht erst danach.
  • Man beachte das Gleichheitszeichen in if Edit1.Text='geheim'. Es ist ein einzelnes Gleichheitszeichen ohne Doppelpunkt. Es beschreibt auch etwas ganz anderes als eine Wertzuweisung: Es beschreibt einen Bedingung. Es gibt nur zwei Möglichkeiten: Die Bedingung ist erfüllt (wahr, engl. true) oder eben nicht (falsch, engl. false).
  • Wenn Du Dich an das Kapitel Lazarus/Variablen_und_Komponenten erinnerst, kamen da Variablen vom Typ boolean vor, die genau diese beiden möglichen Werte hatten. Tatsächlich könnte man einer Variable b vom Typ boolean mit b:=(Edit1.Text='geheim'); einen Wert zuweisen, je nachdem, ob der Text der richtige war oder nicht.

Mehrere Anweisungen zu einem Block gruppieren

Bisher wird in jedem der beiden Fälle genau eine einzelne Anweisung ausgeführt. Es kann aber leicht sein, dass nur im Fall einer erfüllten (oder auch nicht erfüllten) Bedingung gleich mehrere Anweisungen ausgeführt werden sollen. Im nächsten Beispiel soll z.B. bei einer falschen Eingabe auf dem Button die Beschriftung zu 'Nochmal versuchen' geändert weden: Vorlage:Kasten blau Die beiden Anweisungen zum Verändern von Edit2.Text und Button1.Caption sind durch ein begin und ein end umrahmt. Manche Leute sprechen von einem Programm-Block. Natürlich kann auch hinter then ein Programm-Block stehen: Aber Vorsicht: Hinter dem end steht dann wieder kein Semikolon.

Vergleiche von Zahlen

Natürlich kann man nicht nur Zeichenketten miteinander vergleichen, sondern auch Zahlen. Neben der reinen Gleichheit gibt es auch andere Vergleichsoperatoren:

Vergleichsoperator Bedeutung
= gleich
<= kleiner oder gleich
>= größer oder gleich
<> ungleich


Verknüpfung von Bedingungen

In einer if-Abfrage können auch Bedingungen abgefragt werden, die aus mehreren Teilbedingungen bestehen, die durch logische Verknüpfungen verbunden sind. Diese Verknüpfungen sind

Vergleichsoperator Bedeutung
Bedingung1 and Bedingung2 Gilt dann und nur dann, wenn beide Bedingungen erfüllt sind.
Bedingung1 or Bedingung2 Gilt bereits dann, wenn eine der beiden Bedingungen erfüllt sind, aber auch dann, wenn beide erfüllt sind.
Bedingung1 xor Bedingung2 Gilt dann und nur dann, wenn genau eine der beiden Bedingungen erfüllt sind, aber nicht dann, wenn keine oder beide erfüllt sind.
not Bedingung Gilt dann, wenn die Bedingung selbst genau nicht gilt.

Es ist häufig sinnvoll, die einzelnen Bedingungen selbst in Klammern zu setzen.

Aufgaben

  1. Abgestufte Höflichkeit
    In dem Edit-Feld Edit soll ein Vorname eingegeben werden. Wenn es Dein eigener ist, dann soll der Computer gehorsam mit "Willkommen mein Herr und Meister" begrüßen; ansonsten (etwas unfreundicher) mit "Was willst Du?".
  2. Volljährigkeit
    Ist der Bürger 18 Jahre und älter, dann ist er volljährig. Ein Computerprogramm soll auf Knopfdruck das Alter eines Bürgers aus dem Feld Edit1 einlesen und in das Feld Edit2 ausgeben, ob er volljährig ist.
  3. Intervall-Prüfung
    Eine Zahl wird in einer Edit-Komponente eingegeben. Das Programm soll entscheiden, ob diese Zahl zwischen 10 und 20 liegt.
  4. Gefährliche Knöpfe
    Manche Aktionen bei Computerprogrammen sind so risikoreich, dass der Benutzer nicht einmal, sondern dreimal auf den entsprechenden Button klicken sollte, bevor sie ausgeführt werden. Schreibe ein Programm mit dem Knopf "Selbstzerstörung starten", den man drei mal drücken muss, bevor in einem Label der Text: "Selbstzerstörung ist aktiviert" erscheint und der Button selbst unsichtbar wird.
  5. pq-Formel allgemein
    Eine quadratische Funktion sei definiert als . Die so genannte pq-Formel gibt an, welche Nullstellen eine solche Funktion hat:

    Ein Programm soll geschrieben werden, das die Werte p und q aus zwei Edit-Komponenten ausliest und in zwei weitere Edit-Komponenten die Werte der beiden Nullstellen schreibt. Vorausgesetzt natürlich, dass die Funktion überhaupt (reelle) Nullstellen hat (was nicht immer der Fall ist).


Lazarus Logo (new).png

Lazarus-Buch

Abgerufen von „https://unterrichten.zum.de/index.php?title=Lazarus/Schleifen&oldid=96811“