For-Schleife

Monitor eines CBM 3016 mit Commodore-BASIC-Programm, das in Zeile 100 PEEK und POKE in einer FOR-Schleife verwendet.

Die Anzahl der Wiederholungen steht schon beim Eintritt in die 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 Programmiersprachen 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):

For Zähler = Start To Ende Step n
    ' zu
    ' wiederholende
    ' Anweisungen
Next

Die ausdrucksorientierte Schleife erlaubt es auch mit nicht numerischen Schleifenvariablen zu arbeiten. So können zum Beispiel auch verkettete Listen bearbeitet werden.

In C-artigen Programmiersprachen hat eine For-Schleife die Form:

for (Initialisierung; Test; Fortsetzung) Anweisung

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

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

Beispiel für Verwendung als nichtnumerische Schleife:

struct Liste {
    struct Liste *next;
    int element;
};

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

Beispiel für Verwendung als numerische Schleife:

for (i = 0; i < length; i++) {
    …
}

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

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;
            }
        }
    }
}

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;
}

Einige Programmiersprachen (zum Beispiel C++, C#, Java, Perl, Python, PHP, Ruby) bieten ein Konstrukt an, um einer Variable nacheinander alle Elemente einer Liste zuzuweisen. Dieses Konstrukt wird entsprechend seinem üblichen 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.

#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 << " ";
    }
}

foreach (datatype element in enumerable)
{
    …
}

// 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);
    }
}

for Variable_1 in Variable_2'Range loop
    Anweisungen
end loop;

A : array (3..5) of Integer := (5, 9, 10);
for I in A'Range loop
    Put (A(I));
end loop;

foreach Variable (Werte) { Anweisungen }

foreach $name ("Anna", "Heinz", "Sebastian")
{
    print("Hallo, $name.\n");
}

say "Hallo, $_." for qw/Anna Heinz Sebastian/;

for ($i = 0; $i < $length; $i++)
{
    …
}

foreach (Array as Schluessel => Wert)
{
    …
}

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

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

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

Für i=2(1)n: ${\displaystyle a_{i}}$ + 3 = ${\displaystyle a_{i}}$

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.

• Schleife (Programmierung) (While-Schleife, Do-while-Schleife etc.)
• Endlosschleife (Programmierung)

• Auflistung der Syntax von Programmiersprachkonstrukten
• 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.

1. research.att.com (Memento vom 11. Mai 2011 im Internet Archive)
2. cppreference.com Initialisiererlisten