[Anfänger]Kontrollstrukturen und Schleifen

[DenSchub]

Ein kleines Tutorial für Anfänger in Delphi

Kontrollstrukturen und Schleifen

Was sind Kontrollstrukturen und Schleifen?

Sie sind ein wichtiger Teil der Programmiersprache Delphi / Pascal.
Mithilfe dieser Strukturen und Schleifen kann man viele wichtige Sachen erledigen wie z.B.:

• Zählen
• Prüfen, ob etwas einen bestimmten Wert hat
• Dinge x-Mal wiederholen
• Und vieles mehr...

Also, los geht es:

Die If-Then-Struktur

Mithilfe dieser Struktur kann mal Prüfen, ob eine Aussage wahr ist. Dies ist zum Beispiel nützlich, wenn man prüfen möchte, ob der Benutzer bestimme Einstellungen getätigt hat.
Man nutzt diese Struktur folgendermaßen:

Syntax:

Code:

if [Bedingung] then
  [Aktion, die ausgeführt wird wenn die Bedingung wahr (true) ist]

[equote:1cfd604b19="Deutsch:"]Ist die Bedingung [Bedingung] wahr (true), führe den Anweisungsblock aus

[/equote:1cfd604b19]

Beispiel:

Delphi-Quellcode:

if CheckBox1.Checked then
  ShowMessage('Die CheckBox1 wurde angewählt!');

[equote:1cfd604b19="Erklärung:"]Hier wird eine Meldung herausgegeben, falls CheckBox1 angewählt ist

[/equote:1cfd604b19]

Will man einen bestimmten Wert prüfen (z.B. ob zwei Zahlen gleich sind):

Beispiel:

Delphi-Quellcode:

if DemoString = 'Hallo du!' then
Anweisung;

[equote:1cfd604b19="Erklärung:"]Wenn man zwei Werte vergleichen will, macht man dies mit dem =-Operator.
So wird geprüft, ob die linke Seite mit der rechten Seite übereinstimmt

[/equote:1cfd604b19]
Verglichen werden kann eigentlich alles, zu beachten ist nur, dass beide Seiten den gleichen Typ ( z.B. Integer, String... ) haben sollten.

Andere Möglichkeiten mit IF

[equote:1cfd604b19="Andere Operatoren"]Natürlich gibt es nicht nur den =-Operator, es gibt noch mehr:

• = gleich
• <> ungleich
• < kleiner
• > größer
• <= kleiner oder gleich
• >= größer oder gleich

[/equote:1cfd604b19]

Verknüpfen von Bedingungen
Natürlich kann man nicht nur eine Bedingung verwenden. Mann kann sie auch miteinander verknüpfen.

AND

Mit 'and' verknüpft man zwei oder mehr Bedingungen. Dabei müssen alle Bedingungen erfüllt sein.
[equote:1cfd604b19="Beispiel:"]

Delphi-Quellcode:

if (zahl > 0) and (zahl < 10) then
  ShowMessage('Deine Zahl liegt zwischen 1 und 10');

[equote:1cfd604b19="Erklärung"]Hier wird geprüft, ob die Zahl zwischen 1 und 10 liegt und ggf. eine Meldung ausgegeben

[/equote:1cfd604b19]
[/equote:1cfd604b19]

OR

Mit 'or' verknüpft man auch zwei Bedingungen, allerdings muss nur eine davon erfüllt sein.
[equote:1cfd604b19="Beispiel:"]

Delphi-Quellcode:

if (zahl < 1) or (zahl > 10) then
  ShowMessage('Deine Zahl liegt außerhalb von 1-10!');

[equote:1cfd604b19="Erklärung:"]Hier wird geprüft, ob die Zahl außerhalb von 1-10 liegt und ggf. eine Meldung herausgegeben.

[/equote:1cfd604b19]
[/equote:1cfd604b19]
Wie auch immer man es macht, die Bedingungen müssen dann immer eingeklammert sein.

Hinweise:

• Wenn die Aktion, die ausgeführt werden soll, länger als eine Zeile ist, muss sie in ein Begin-End-Block geschrieben werden. Also:
  Code:

  if [Bedingung] then
    begin
      [Anweisungs-Block]
    end;

• If-Strukturen lassen sich verschachteln

Tipps:

• Prüfe nie auf '= true'! Wenn du das haben willst, lasse das '= true' einfach weg, das hat den selben Effekt.
• Genauso ist es mit '= false', hänge dann einfach ein 'not' vor die Bedingung, z.B.: if not Checked then

[equote:1cfd604b19="Warum?"]Hier findest du eine Antwort

[/equote:1cfd604b19]

Die If-Then-Else-Struktur

Die If-Then-Else-Struktur gleicht der If-Then-Struktur, allerdings wird bei dieser Struktur, falls die Bedingung falsch (false) ist, ein anderer Anweisungs-Block / eine andere Anweisung ausgeführt
Diese Struktur wird folgendermaßen benutzt:

Syntax:

Code:

if [Bedingung] then
  [Aktion, die ausgeführt wird, wenn die Bedingung wahr (true) ist]
else
  [Aktion, die ausgeführt wird, wenn die Bedingung falsch (false) ist]

[equote:1cfd604b19="Deutsch"]Ist die Bedingung [Bedingung] wahr (true), führe den Anweisungsblock aus. Ist sie nicht wahr, führe den zweiten Anweisungsblock aus

[/equote:1cfd604b19]

Beispiel:

Delphi-Quellcode:

if CheckBox1.Checked then
  Form2.Show
else
  Form3.Show;

[equote:1cfd604b19="Erklärung:"]Wenn die CheckBox1 gewählt ist, wird das Formular Forum2 angezeigt. Falls nicht wird das Formular Form3 angezeigt

[/equote:1cfd604b19]

Auch hier gilt:
Ist die Aktion länger als eine Anweisung, muss der Anweisungs-Block in Begin & End gefasst werden.

Die Tipps von oben gelten auch hier.

Hinweis:

Vor dem 'else' darf nie ein Semikolon stehen!

Es ist sehr Umständlich, wenn man z.B. eine Zahl hätte, und abhängig davon eine spezielle Antwort geben muss. Normalerweise würde man dieses Problem so lösen:

Delphi-Quellcode:

if zahl = 0 then
  Antwort0;
if zahl = 1 then
  Antowrt1;
if zahl = 2 then
  Antwort2;
if zahl = 3 then
  Antwort3;
if zahl = 4 then
  Antwort4;
if zahl = 5 then
  Antwort5;

Dafür gibt es aber auch eine elegante Lösung:

Die Case-Of-Struktur

Die Case-Of-Struktur sieht aus wie eine Aufzählung, das ist sie im Prinzip auch.
Sie enthält eine Liste aller Werte, gefolgt von einem Doppelpunkt und der Aktion, die jeweils ausgeführt werden soll.

Syntax:

Code:

case [Variable] of
  0: [Anweisung1]
  1: [Anweisung2]
  2: [Anweisung3]
  3: [Anweisung4]
  4: [Anweisung5]
  5: [Anweisung6]
  ...
end;

[equote:1cfd604b19="Deutsch:"]Die Case-Of-Struktur sucht sich den Wert einer Variable und führt entsprechend eine Aktion aus.

[/equote:1cfd604b19]

Hinweise:

• Die Variable muss ein ordinaler Typ sein!
  [equote:1cfd604b19="Erklärung:"]Zu den ordinalen Typen gehören Integer-, Zeichen-, Aufzählungs-, Teilbereichs- und Boolesche Typen.Sie müssen einen eindeutigen Vorgänger und Nachfolger haben (Ausnahmen: Erste und letzte Position).Für den Anfang braucht man nur zu wissen, dass Integer ein ordinaler Typ ist. Wer sich genauer damit beschäftigen will, kann in der Delphi-Hilfe nachschlagen

• Case-Of-Strukturen müssen mit einem 'end;' abgeschlossen werden.
• Case-Of unterstützt auch ein 'else', das dann eintrifft, wenn keiner der anderen Werte eintrifft:
  
  Delphi-Quellcode:

  case zahl of
    0: Anweisung1;
    1: Anweisung2;
  else
    Anweisung3;
  end;

• Bei Case-Of kann man auch ganze Wertebereiche angeben, dass ist z.B. sehr Praktisch, wenn man Zahlen und Buchstaben unterscheiden möchte:
  
  Delphi-Quellcode:

  case key of
    'A'..'Z','a'..'z': ShowMessage('Buchstabe');
    '0'..'9','.': ShowMessage(Zzahl');
    #13,#20: ShowMessage(Wwhitespace');
  else
    ShowMessage('Nix von alledem');
  end;

[/equote:1cfd604b19]

Beispiel:

Dieses Beispiel ist die neue Version von unserem Code-Segment von oben!

Delphi-Quellcode:

case zahl of
  0: Antwort0;
  1: Antwort1;
  2: Antwort2;
  3: Antwort3;
  4: Antwort4;
  5: Antwort5;
end;

[equote:1cfd604b19="Erklärung:"]Die Variable zahl vom Typ Integer hat den Wert 0-5. Je nachdem, welchen Wert sie besitzt, gibt das Programm eine entsprechende Antwort aus.

[/equote:1cfd604b19]



Was ist, wenn man eine Anweisung 5 mal wiederholen möchte?
So ist es umständlich:

Delphi-Quellcode:

Anweisung;
Anweisung;
Anweisung;
Anweisung;
Anweisung;

Einfacher geht es mit der

Die for-do-Schleife

Diese Schleife wiederholt etwas, bis ein ordinaler Typ (Erklärung siehe Oben) einen Zielwert erreicht hat.
Es wird zunächst ein Startwert definiert, von dem die Schleife hoch oder herunter zählt.
Ist der Zielwert erreicht, wird die Schleife abgebrochen.

Syntax:

Code:

for [Variable] := [Startwert] to [Zielwert] do
  [Anweisung]

[equote:1cfd604b19="Deutsch:"]Zähle von einem Startwert zu einem Zielwert herauf / herunter. Solange der Aktuelle Wert der Zählervariable unter oder auf dem Zielwert liegt, führe den Anweisungsblock aus.

[/equote:1cfd604b19]

Beispiel:

Das ist die neue Version unserem Code-Segment oben!

Delphi-Quellcode:

for i:=0 to 4 do
  Anweisung;

[equote:1cfd604b19="Erklärung:"]Die Anweisung 'Anweisung' wird fünf mal ausgeführt.

[/equote:1cfd604b19]

Noch ein Vorteil dieser Schleife:
Man erzeugt eine StringList und möchte so etwas hineinschreiben:

Code:

1
2
3
4
5

Muss man es ja jedes mal so machen, oder?

Delphi-Quellcode:

StringList.Add('1');
StringList.Add('2');
StringList.Add('3');
StringList.Add('4');
StringList.Add('5');

Nein! Mann kann da auch die For-Schleife verwenden:

Beispiel

Das ist die neue Version unseres Codes oben!

Delphi-Quellcode:

for i := 1 to 5 do
  StringList.Add(IntToStr(i));

[equote:1cfd604b19="Erklärung:"]Die Anweisung wird fünf mal ausgeführt. Zusätzlich wird in der Anweisung die Zählervariable 'i' verwendet

[/equote:1cfd604b19]
Na, ist doch viel einfacher!
Du siehst, dass man nicht zwangsläufig als Startwert die 0 haben muss, es geht mit allen Werten.

Hinweis:

Die Zähler-Variable muss natürlich deklariert und ein ordinaler Typ sein!

Tipp:

Wenn du herunter zählen möchtest, ersetze einfach das 'to' zwischen dem Start- und Zielwert durch ein 'downto'

Die repeat-until-Schleife

Diese Schleife wiederholt etwas, bis eine Bedingung erfüllt ist.
Der Anweisungsblock wird mindestens einmal ausgeführt, da die Bedingung erst am Ende geprüft wird. Ist die Bedingung dann nicht wahr, wird der Anweisungsblock wiederholt:

Syntax:

Code:

repeat
  [Anweisungen]
until
  [Bedingung]

[equote:1cfd604b19="Deutsch:"]Wiederhole einen Anweisungsblock solange, bis eine Bedingung erfüllt ist

[/equote:1cfd604b19]

Beispiel:

Dieser Code hat den selben Effekt wie das zweite Beispiel aus der For-Do-Schleife!

Delphi-Quellcode:

i := 0;
repeat
  inc(i);
  StringList.Add(IntToStr(i));
until
  i > 4;

[equote:1cfd604b19="Erklärung:"]Der Anweisungsblock wird fünf mal ausgeführt. Im Anweisungsblock wird zuerst die Variable 'i' Inkrementiert (hochgezählt) und dann den Wert der Variable 'i' in die StringList geschrieben.

[/equote:1cfd604b19]

Hinweise:

• Die Schleife wird mindestens einmal durchgeführt, da die Bedingung erst am Ende geprüft wird!
• Zwischen repeat und until brauchst du keine begin &amp; end! Auch nicht, wenn du einen Anweisungsblock mit mehreren Zeilen hast.

Die while-do-Schleife

Diese Schleife ist eigentlich im Grunde das gleiche wie die repeat-until-Schleife.
Allerdings wird diese Schleife nur Ausgeführt, wenn die Bedingung wahr ist:

Syntax:

Code:

while [Bedingung] do
  [Anweisungen]

[equote:1cfd604b19="Deutsch:"]Solange die Bedingung erfüllt ist, führe die Anweisungen aus

[/equote:1cfd604b19]

Beispiel:

Wieder mit dem selben Ergebnis!

Delphi-Quellcode:

i := 0;
while i < 5 do
  begin
    inc(i);
    StringList.Add(IntToStr(i));
  end;

[equote:1cfd604b19="Erklärung:"]Die Schleife wird fünf mal durchlaufen. Im Anweisungsblock wird zunächst die Variable 'i' hochgezählt, dann den Wert in eine StringList geschrieben.

[/equote:1cfd604b19]

Hinweis:

Hier brauchst du wieder, bei mehreren Anweisungen, ein begin & end!

Wichtiger Hinweis zu der Repeat-Until-Schleife und der While-Do-Schleife!

In dieses Schleifen gibt es keine feste Zählervariable, d.h. du müsst selber dafür sorgen, dass die Erfüllung der Bedingung möglich ist!
Tust du das nicht, gelangst du in eine Endlos-Schleife!

Viel Spaß und gutes Gelingen wünscht

Dennis

[DeddyH]

Zitat:

If-Schleifen lassen sich verschachteln

Wirf mal einen Blick in meine Signatur. Na denn Prost

[DenSchub]

Wo steht das denn?

[DeddyH]

Jaja

[Namenloser]

Ich hab jetzt nicht alles durchgelesen, aber das Tutorial mal überflogen. Die wichtigsten Dinge werden für Anfänger gut und verständlich erklärt. Vielleicht solltest du etwas mehr auf Tippfehler achten (Case Od, Synatx etc.).
Zwei Sachen könntest du meiner Ansicht nach noch verbessern: a) praxisnähere/interessantere Beispiele, b) etwas mehr auf den Unterschied zwischen repeat- und while-Schleife eingehen (z.B. dass die repeat-Schleife mindestens einmal durchlaufen wird, und wann welche Schleifenform wann sinnvoll ist).

Alels in allem ein gutes Tutorial, denke ich



//Edit: Bei der If-Struktur ist es etwas verwirrend, dass du schreibst, niemals auf "= True" zu prüfen, obwohl du gar nicht erwähnt hast, dass man überhaupt mit = auf einen Wert prüfen kann. Das sollte, finde ich, noch rein.

[DenSchub]

Zitat:

//Edit: Bei der If-Struktur ist es etwas verwirrend, dass du schreibst, niemals auf "= True" zu prüfen, obwohl du gar nicht erwähnt hast, dass man überhaupt mit = auf einen Wert prüfen kann. Das sollte, finde ich, noch rein.

Danke, ist drinne! Ich werde noch das mit den 'AND' und 'OR' dazuschreiben.

[Die Muhkuh]

Hi,

ganz nett. Beim Case-Of solltest Du noch erwähnen, dass es auch ein else unterstützt, falls gar keiner der Werte zu trifft:

Delphi-Quellcode:

Zahl := 2;
case Zahl of
  0: Anweisung0;
  1: Anweisung1;
else
  ShowMessage('Keine definierte Anweisung');
end;

[DenSchub]

Danke Manuel, habe es hinzugefügt!

[Namenloser]

Was mir grad einfällt ist, dass du beim case auch Wertbereiche angeben kannst.
Beispiel:

Delphi-Quellcode:

case key of
'A'..'Z','a'..'z': showmessage('buchstabe');
'0'..'9','.': showmessage('zahl');
#13,#20: showmessage('whitespace');
end;

Das solltest du vllt. auch noch erwähnen, weil es unter Umständen sehr praktisch sein kann.

[bluesbear]

Hi DenSchub,
was mir gerade auffiel ist eine etwas missverständliche Formulierung zur repeat-Schleife:

Zitat:

Diese Schleife wiederholt etwas, bis eine Bedingung erfüllt ist.
Der Anweisungsblock wird nur ausgeführt, wenn die Bedingung nicht wahr ist:

Bei einer repeat-Schleife wird der Anweisungsblock mindestens einmal ausgeführt, deshalb wird sie auch "nichtabweisende Schleife" genannt. Die Bedingung bestimmt nur, ob die Ausführung wiederholt wird.
Eine while-Schleife wird auch "abweisende Schleife" genannt, denn da wird die Bedingung vor dem Anweisungsblock geprüft, und dieser gegebenenfalls nicht ausgeführt. [/klugscheiß]