imported>KlartextJan: /* Einzelnachweise Link Archivierung*/

2024-02-13T10:02:18Z

Einzelnachweise Link Archivierung

Neue Seite

[[Datei:Zählschleife.png|mini|[[Nassi-Shneiderman-Diagramm|Struktogramm]] einer For-Schleife]]
Viele [[Programmiersprache]]n definieren eine '''For-Schleife''' als eine [[Kontrollstruktur]], mit der man eine Gruppe von [[Anweisung (Programmierung)|Anweisungen]] (Block) mit einer bestimmten Anzahl von Wiederholungen bzw. Argumenten ausführen kann.

Die Definition, wie eine For-Schleife auszusehen hat ([[Syntax]]), ist von Programmiersprache zu Programmiersprache unterschiedlich. Auch die Bedeutung einer For-Schleife ([[Semantik]]), also die Art, wie sie ausgeführt wird, ist von Sprache zu Sprache verschieden. Die Elemente, aus denen eine For-Schleife besteht, sind aber fast immer dieselben.

== Numerische Schleife ==
[[Datei:Monitor Commodore CBM 3016 with BASIC program-0309.jpg|mini|Monitor eines [[CBM-3000-Serie|CBM 3016]] mit [[Commodore BASIC|Commodore-BASIC]]-Programm, das in Zeile 100 [[POKE und PEEK|PEEK und POKE]] in einer FOR-Schleife verwendet.]]
Die Anzahl der Wiederholungen steht schon beim Eintritt in die [[Schleife (Programmierung)|Schleife]] fest. Es gibt eine Schleifenvariable, die am Anfang auf den Startwert gesetzt wird und dann jeweils um die Schrittweite verändert wird, bis der Zielwert erreicht ist. Die Schleifenvariable, der Startwert, die Schrittweite und der Endwert müssen numerisch sein. Diese Form der Schleife ist daher auch unter dem Begriff ''Zählschleife'' bekannt.

In den meisten [[Programmiersprache]]n sind Start-, Endwert und Schrittweite auf ganze Zahlen beschränkt. Bei manchen Sprachen ist die Schrittweite auf 1 (bzw. −1 mit ''downto'' statt ''to'') beschränkt.

Die Grundstruktur dieser For-Schleifen ist folgende (hier am Beispiel [[BASIC]]):
<syntaxhighlight lang="vbnet">
For Zähler = Start To Ende Step n
' zu
' wiederholende
' Anweisungen
Next
</syntaxhighlight>

== Ausdrucksorientierte Schleife ==

Die [[Ausdrucksorientierte Programmiersprache|ausdrucksorientierte]] [[Schleife (Programmierung)|Schleife]] erlaubt es auch mit nicht numerischen Schleifenvariablen zu arbeiten. So können zum Beispiel auch [[verkettete Liste]]n bearbeitet werden.

In C-artigen [[Programmiersprache]]n hat eine For-Schleife die Form:

<syntaxhighlight lang="c">
for (Initialisierung; Test; Fortsetzung) Anweisung
</syntaxhighlight>

Und so wird sie ausgeführt (nach [[ISO/IEC 9899:1999]]):

# Der Ausdruck ''Initialisierung'' wird ausgewertet. Falls es sich dabei um eine [[Deklaration (Programmierung)|Deklaration]] handelt, sind die darin definierten [[Variable (Programmierung)|Variablen]] nur innerhalb der For-Schleife gültig.
# Der Ausdruck ''Test'' wird als [[Boolesche Variable|boolescher]] Ausdruck ausgewertet. Falls der Wert '''false''' ist, wird die For-Schleife beendet.
# Die Anweisung ''Anweisung'' wird ausgeführt.
# Der Ausdruck ''Fortsetzung'' (meistens eine [[Anweisung (Programmierung)|Anweisung]]) wird ausgewertet.
# Es geht mit 2. weiter.

Beispiel für Verwendung als nichtnumerische Schleife:

<syntaxhighlight lang="c">
struct Liste {
struct Liste *next;
int element;
};

for (p = liste; p != NULL; p = p->next) {
…
}
</syntaxhighlight>

Beispiel für Verwendung als numerische Schleife:

<syntaxhighlight lang="c">
for (i = 0; i < length; i++) {
…
}
</syntaxhighlight>

== Verschachtelte For-Schleifen ==
Innerhalb einer For-Schleife können sich eine oder mehrere weitere For-Schleifen befinden. Das sind verschachtelte For-Schleifen.

=== Beispiele ===
Das [[Sortierverfahren]] [[Bubblesort]] verwendet zwei verschachtelte For-Schleifen. In der inneren [[Schleife (Programmierung)|Schleife]] werden benachbarte Elemente vertauscht.<syntaxhighlight lang="csharp">
public void Bubblesort(object[] elements)
{
for (int i = elements.Length - 1; i > 0; i--)
{
for (int j = 0; j < i; j++)
{
object element1 = elements[j];
object element2 = elements[j + 1];
if (element1 > element2)
{
elements[j] = element2;
elements[j + 1] = element1;
}
}
}
}
</syntaxhighlight>Die folgende [[Methode (Programmierung)|Methode]] berechnet die [[Binomialkoeffizient]]en im [[Pascalsches Dreieck|Pascalschen Dreieck]] und gibt ein [[Zweidimensional|zweidimensionales]] [[Feld (Datentyp)|Array]] zurück:<syntaxhighlight lang="csharp">
public int[][] Binomial(int n)
{
int[][] binomials = new int[n][];
binomials[0] = new int[1];
binomials[0][0] = 1;
for (int i = 1; i < n; i++)
{
binomials[i] = new int[i + 1];
for (int j = 0; j <= i; j++)
{
int left = 0;
if (j > 0)
{
left = binomials[i - 1][j - 1];
}
int right = 0;
if (j < i)
{
right = binomials[i - 1][j];
}
binomials[i][j] = left + right;
}
}
return binomials;
}
</syntaxhighlight>
== Foreach-Schleife ==

Einige [[Programmiersprache]]n (zum Beispiel [[C++]], [[C-Sharp|C#]], [[Java (Programmiersprache)|Java]], [[Perl (Programmiersprache)|Perl]], [[Python (Programmiersprache)|Python]], [[PHP]], [[Ruby (Programmiersprache)|Ruby]]) bieten ein Konstrukt an, um einer [[Variable (Programmierung)|Variable]] nacheinander alle Elemente einer [[Liste (Datenstruktur)|Liste]] zuzuweisen. Dieses Konstrukt wird entsprechend seinem üblichen [[Schlüsselwort (Programmierung)|Schlüsselwort]] meist Foreach-Schleife genannt. Je nach Programmiersprache unterscheiden sich Notation und Schlüsselwort jedoch. So wird die Foreach-Schleife in [[Object Pascal]] und [[JavaScript]] als For-In-Schleife bezeichnet. In JavaScript wird der Variable entgegen der oben genannten Beschreibung nur der Index bzw. Schlüssel zugewiesen und nicht das Element selbst, denn für letzteres gibt es die For-Of-Schleife.

=== C++ ===
Ab der Version C++11 gibt es in [[C++]] die ''bereichsbasierte For-Schleife'' (engl. ''range-based for'').<ref>{{Webarchiv |url=http://www2.research.att.com/~bs/C++0xFAQ.html#for |text=research.att.com |wayback=20110511182819 |archiv-bot=}}</ref> Diese vereinfacht das Iterieren über beliebige Container und andere Objekte, für die die [[Funktion (Programmierung)|Funktionen]] <code>std::begin</code> und <code>std::end</code> [[überladen]] worden sind, z. B. alle Container der [[Standardbibliothek]], aber auch über eingebaute [[Feld (Datentyp)|Arrays]] (''C-style arrays'') oder benutzerdefinierte Containerdatentypen:

<syntaxhighlight lang="cpp">
#include <iostream>
#include <vector>

int main() {
std::vector<int> vec(5); // Initialisiere vec mit 5 Zellen

// range-basierte for-Schleife über Initialisiererliste (std::initializer_list) und Zuweisung an die Vektorelemente
for (auto i: {1, 2, 3, 4, 5}) {
vec[i-1] = i;
}

// range-basierte for-Schleife über Vektor
for (auto i: vec) {
std::cout << i << " ";
}
}
</syntaxhighlight>
<ref>[http://en.cppreference.com/w/cpp/utility/initializer_list cppreference.com] Initialisiererlisten</ref>

Das hierbei benutzte [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>auto</code> bringt den [[Compiler]] dazu, automatisch den benötigten Typ zu nutzen (wäre bei beiden [[Schleife (Programmierung)|Schleifen]] <code>int</code>).

=== C# ===
In [[C-Sharp|C#]] hat die foreach-Schleife folgende Form:<syntaxhighlight lang="csharp">
foreach (datatype element in enumerable)
{
…
}
</syntaxhighlight>Im folgenden Beispiel durchläuft die foreach-Schleife alle Länder der [[Generische Programmierung|generischen]] Liste und gibt alle Länder aus, deren Name auf "land" endet:<syntaxhighlight lang="csharp">
// Generische Liste der Länder
List<string> countries = new List<string>();

// Liste füllen
countries.Add("Germany");
countries.Add("Austria");
countries.Add("Switzerland");
countries.Add("France");
countries.Add("Poland");
countries.Add("United States");

// Die foreach-Schleife durchläuft der Reihe nach alle Elemente der Liste
foreach (string country in countries)
{
if (country.EndsWith("land"))
{
Console.WriteLine(country);
}
}
</syntaxhighlight>
=== Ada ===
Eine Foreach-Schleife in [[Ada (Programmiersprache)|Ada]] hat die Form:
<syntaxhighlight lang="ada">
for Variable_1 in Variable_2'Range loop
Anweisungen
end loop;
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="ada">
A : array (3..5) of Integer := (5, 9, 10);
for I in A'Range loop
Put (A(I));
end loop;
</syntaxhighlight>

=== Perl ===

Eine For oder Foreach-Schleife (beide Schlüsselworte sind synonym in [[Perl (Programmiersprache)|Perl]]) hat die Form:
<syntaxhighlight lang="perl">
foreach Variable (Werte) { Anweisungen }
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="perl">
foreach $name ("Anna", "Heinz", "Sebastian")
{
print("Hallo, $name.\n");
}
</syntaxhighlight>

''$name'' ist die [[Variable (Programmierung)|Variable]], die nacheinander die Werte in den Klammern zugewiesen bekommt.

Enthält der Schleifenblock nur einen Befehl, kann auch die nachgestellte Form eingesetzt werden, welche allerdings keine selbstbenannte Laufvariable erlaubt:
<syntaxhighlight lang="perl">
say "Hallo, $_." for qw/Anna Heinz Sebastian/;
</syntaxhighlight>

Eine Verwendung wie in C ist ebenfalls möglich:
<syntaxhighlight lang="perl">
for ($i = 0; $i < $length; $i++)
{
…
}
</syntaxhighlight>

=== PHP ===

Eine Foreach-Schleife in [[PHP]] hat die Form:

<syntaxhighlight lang="php">
foreach (Array as Schluessel => Wert)
{
…
}
</syntaxhighlight>

''Schluessel'' und ''Wert'' wird in jedem Schleifendurchlauf ein Schlüssel-Wert-Paar aus dem [[Feld (Datentyp)|Array]] zugewiesen. PHP-Arrays unterscheiden sich zu vielen anderen [[Programmiersprache]]n dadurch, dass jeder Eintrag ein Schlüssel-Wert-Paar sein kann, nicht nur ein einfacher Wert.

Im Gegensatz zu [[Perl (Programmiersprache)|Perl]] ist die Syntax nicht an der mathematischen Lesart angelehnt, so dass es komisch klingt, wenn man den Code vorliest. Das kann insbesondere bei Programmieranfängern oder Umsteigern zu Problemen führen. In den meisten anderen Programmiersprachen folgt nämlich auf das Schlüsselwort '''foreach''' der Name der Variablen, die nacheinander die verschiedenen Werte annimmt.

Beispiel:

<syntaxhighlight lang="php">
<?php
$namen = array (
"Albert" => "Einstein",
"Rasmus" => "Lerdorf",
"Stephen William" => "Hawking"
);

foreach ($namen as $vorname => $nachname)
{
print("Hallo, $vorname $nachname\n");
}
?>
</syntaxhighlight>

== Historisches: Die Für-Schleife von „Superplan“ ==
[[Heinz Rutishauser]] entwickelte von 1949 bis 1951 die einfache algebraische Programmiersprache „[[Superplan]]“. Rutishauser kannte [[Konrad Zuse]]s Arbeit über Programmiersprachen, d. h. Zuses [[Plankalkül]] und wählte den Namen in Anlehnung an Zuses Bezeichnung „Rechenplan“ für ein einzelnes Programm.<br />
Rutishausers einfache Sprache hatte nur eine Kontrollstruktur: die '''Für'''-Anweisung bzw. '''Für'''-Schleife.

'''Für''' i=2(''1'')n: <math>a_i </math> + 3 = <math>a_i </math>

bedeutet z. B., dass in einem Array a zu allen (d. h. es wird mit der ''Schrittweite 1'' weitergezählt) Elementen von Index ''Startwert'' 2 ausgehend bis zu Index ''Zielwert'' n eine 3 hinzuaddiert wird.

== Siehe auch ==
* [[Schleife (Programmierung)]] (While-Schleife, Do-while-Schleife etc.)
* [[Endlosschleife (Programmierung)]]

== Weblinks ==
* [http://merd.sourceforge.net/pixel/language-study/syntax-across-languages.html#CntrFlowLoop Auflistung der Syntax von Programmiersprachkonstrukten]
* [http://www.knosof.co.uk/cbook/cbook.html ''The New C Standard: An Economic and Cultural Commentary''.] Englischsprachiges Buch, das C in aller Ausführlichkeit behandelt und mit anderen Sprachen vergleicht. Die For-Schleife ist ab Seite 1428 (Kap. 6.8.5.3) im PDF-Dokument erklärt.

== Einzelnachweise ==
<references />

[[Kategorie:Programmiersprachelement]]

For-Schleife - Versionsgeschichte

imported>KlartextJan: /* Einzelnachweise Link Archivierung*/