„Iterative Programmierung“ – Versionsunterschied

Versionsgeschichte interaktiv durchsuchen

[gesichtete Version]

Inhalt gelöscht Inhalt hinzugefügt

Inline

Aktuelle Version vom 19. Dezember 2023, 22:43 Uhr

Die iterative Programmierung (von lat. iterare = wiederholen) ist ein Konzept, bei dem mehrfach auszuführende Arbeitsschritte in Schleifen (Wiederholungen von Anweisungen oder Anweisungsfolgen) umgesetzt werden.

Abgrenzung

Andere Programmierkonzepte sind

die rekursive Programmierung, die für mehrfach auszuführende Arbeitsschritte Rekursion verwendet (wiederholte Selbstaufrufe eines Programmteils); prinzipiell lassen sich rekursive Algorithmen auch iterativ implementieren und umgekehrt.
die logische Programmierung, die Lösungen für Probleme nicht über Anweisungsfolgen findet, sondern durch regelbasierte logische Folgerung.

Gegenüberstellung

In der Literatur werden Funktionen gerne im rekursiven Programmierstil vorgestellt, die meist als einfacher zu verstehen gelten. Bei rekursiver Programmierung wird die Wiederholung erreicht, ohne dass das Programm explizite Schleifen enthält.^[1] Anstatt Schleifenkontrollanweisungen enthält das Programm sogenannte (direkte) Selbstaufrufe der betreffenden Funktion oder auch indirekte gegenseitige Aufrufe mehrerer Funktionen untereinander. In beiden Fällen, iterativer wie rekursiver Programmierung, bedarf es normalerweise einer expliziten Abbruchbedingung, die eine Terminierung des Programms erzwingt, wobei Fehler in derselben zu unbeabsichtigten Endlosschleifen führen können.

Iterative Implementierungen bieten oft Vorteile:

Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver normalerweise bei jedem Selbstaufruf der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim Rücksprung wieder hergestellt werden kann.^[2]
Darüber hinaus ist der Speicherbedarf für den Programm-Stapelspeicher programmiersprachlich schwer oder gar nicht kontrollierbar. Auch die Anzahl der Wiederholungen (resp. Selbstaufrufe) ist bei rekursiver Programmierung manchmal weniger deutlich erkennbar. Beide Probleme mögen zu den berüchtigten Stapelüberläufen beitragen.
Im rekursiven Programmierstil lassen sich manche Szenarien nur durch eine sogenannte Rückruffunktion (englisch callback function) realisieren. Beispielsweise wird bei einer rekursiv programmierten Traversierfunktion eines Binärbaums dieser stets in seiner Gänze durchlaufen und die Nutzfunktion in einem Rückruf implementiert.
Im Gegensatz dazu kann bei iterativer Programmierung das zu bearbeitende Segment des Baums durch eine Suchfunktion angesteuert, die Nutzfunktion nach Belieben als flache Anweisungsfolge bzw. als Unterprogramm implementiert und nach einem (iterativen) Querschritt beim nächsten Element wiederholt werden.^[3]

Mit wachsender Leistungsfähigkeit der Rechner tritt jedoch die Lesbarkeit und Wartbarkeit von Software gegenüber ihrer technischen Effizienz in den Vordergrund. Wo dies der Fall ist, bietet sich der rekursive Ansatz für die Arbeit mit baumartigen Datenstrukturen und der iterative für sequenzielle Datenstrukturen an.

Beispiel

Ein Beispiel für die iterative Programmierung ist ein Datenbankdurchlauf (Pascal) durch die Datensätze („Zeilen“) von (der „Tabelle“) Dataset:

procedure Durchlauf;
begin
    while not Dataset.Eof do                  ! wiederhole_solange Tabelle Dataset nicht „zu Ende“ ist
    begin                                     ! den hier beginnenden Befehlsblock
        Befehl1;
        Befehl2;
        Befehl3;
        Dataset.Next;                         !  Schalte weiter zum nächsten Datensatz (nächste „Zeile“) von Dataset.
    end;
end;

Dabei werden die Befehle 1 bis 3 solange wiederholt, bis alle Datensätze durchlaufen wurden.

Anmerkungen und Einzelnachweise

↑ Niklaus Wirth: Algorithmen und Datenstrukturen, B. G. Teubner 1983, Seite 150
↑ Ausnahmen sind Programmiersysteme und Compiler, die Unterstützung dafür bieten, Endrekursionen zu erkennen und zu optimieren.
↑ Siehe dazu Traversierung (mit Codebeispielen) und Ben Pfaff: An Introduction to Binary Search Trees and Balanced Trees. Free Software Foundation, Inc. Boston 2004, S. 47 „4.9.2 Traversal by Iteration“.

[1] Niklaus Wirth: Algorithmen und Datenstrukturen, B. G. Teubner 1983, Seite 150

[2] Ausnahmen sind Programmiersysteme und Compiler, die Unterstützung dafür bieten, Endrekursionen zu erkennen und zu optimieren.

[3] Siehe dazu Traversierung (mit Codebeispielen) und Ben Pfaff: An Introduction to Binary Search Trees and Balanced Trees. Free Software Foundation, Inc. Boston 2004, S. 47 „4.9.2 Traversal by Iteration“.

[1]

[2]

[3]

@@ Zeile 1: / Zeile 1: @@
-Die '''[[:wikt:iterativ|iterative]] Programmierung''' (von ''[[Latein|lat.]]'' iterare = wiederholen) verwendet im Gegensatz zur [[Rekursive Programmierung|rekursiven Programmierung]] keine Selbstaufrufe, sondern [[Schleife (Programmierung)|Schleife]]n (Wiederholungen von [[Anweisung (Programmierung)|Anweisungen]] oder Anweisungsfolgen). Prinzipiell lassen sich rekursive [[Algorithmus | Algorithmen]] auch iterativ implementieren und umgekehrt.
+Die '''iterative Programmierung''' (von ''[[Latein|lat.]]'' iterare = wiederholen) ist ein Konzept, bei dem mehrfach auszuführende Arbeitsschritte in [[Schleife (Programmierung)|Schleife]]n (Wiederholungen von [[Anweisung (Programmierung)|Anweisungen]] oder Anweisungsfolgen) umgesetzt werden.
-== Gegenüberstellung ==
+== Abgrenzung ==
+Andere Programmierkonzepte sind
-In der Literatur werden Funktionen gerne im [[Rekursive Programmierung|rekursiven Programmierstil]] vorgestellt.
+* die [[rekursive Programmierung]], die für mehrfach auszuführende Arbeitsschritte [[Rekursion]] verwendet (wiederholte Selbstaufrufe eines Programmteils); prinzipiell lassen sich rekursive [[Algorithmus|Algorithmen]] auch iterativ implementieren und umgekehrt.
-Der Anwender hat aber mehrere Vorteile davon, wenn der Implementierer die vom Aufschreiben her eleganten Rekursionen durch simple Iterationen ersetzt:
+* die [[logische Programmierung]], die Lösungen für Probleme nicht über Anweisungsfolgen findet, sondern durch regelbasierte logische Folgerung.
-* Bei iterativer Programmierung kann der Speicherbedarf genauer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver unvermeidlich bei jedem Selbstaufruf der ganze Kontext einer Prozedur gerettet wird.
-* Darüber hinaus ist der Speicherbedarf für den Programm-[[Stapelspeicher]] programmiersprachlich schwer oder gar nicht kontrollierbar, wovon die berüchtigten [[Stapelüberlauf|Stapelüberläufe]] eine Folge sind.
+=== Gegenüberstellung ===
-* Im rekursiven Programmierstil lassen sich manche Szenarien nur durch eine sog. Rückruffunktion ({{enS|''callback function''}}) realisieren. Beispielsweise wird bei einer rekursiv programmierten [[Binärbaum#Traversierung|Traversierfunktion]] eines Binärbaums dieser stets in seiner Gänze durchlaufen und die Nutzfunktion in einem Rückruf implementiert. Im Gegensatz dazu kann bei iterativer Programmierung das zu bearbeitende Segment des Baums durch eine [[Binärer Suchbaum#Suchen|Suchfunktion]] angesteuert, die Nutzfunktion nach Belieben als flache Anweisungsfolge bzw. als Unterprogramm implementiert und nach einem [[Binärbaum#Iterative Implementierung|(iterativen) Querschritt]] beim nächsten Element wiederholt werden.<ref>Siehe dazu [[Binärbaum#Traversierung|Traversierung]] (mit Codebeispielen) und Ben Pfaff: ''An Introduction to Binary Search Trees and Balanced Trees.'' Free Software Foundation, Inc. Boston 2004, S. 47 „4.9.2 Traversal by Iteration“.</ref>
+In der Literatur werden Funktionen gerne im [[Rekursive Programmierung|rekursiven Programmierstil]] vorgestellt, die meist als einfacher zu verstehen gelten. Bei [[rekursive Programmierung|rekursiver Programmierung]] wird die Wiederholung erreicht, ohne dass das Programm explizite Schleifen enthält.<ref> [[Niklaus Wirth]]: ''Algorithmen und Datenstrukturen'', [[B. G. Teubner]] 1983, Seite 150</ref> Anstatt Schleifenkontrollanweisungen enthält das Programm sogenannte (direkte) Selbstaufrufe der betreffenden Funktion oder auch indirekte gegenseitige Aufrufe mehrerer Funktionen untereinander. In beiden Fällen, iterativer wie rekursiver Programmierung, bedarf es normalerweise einer expliziten [[Abbruchbedingung]], die eine [[Terminiertheit|Terminierung]] des Programms erzwingt, wobei Fehler in derselben zu unbeabsichtigten [[Endlosschleife (Programmierung)|Endlosschleife]]n führen können.
+Iterative Implementierungen bieten oft Vorteile:
+* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver normalerweise bei jedem Selbstaufruf der Kontext der aufrufenden Prozedur (im Programm-[[Stapelspeicher]]) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann.<ref>Ausnahmen sind Programmiersysteme und Compiler, die Unterstützung dafür bieten, [[Endrekursion]]en zu erkennen und zu optimieren.</ref>
+* Darüber hinaus ist der Speicherbedarf für den Programm-Stapelspeicher programmiersprachlich schwer oder gar nicht kontrollierbar. Auch die Anzahl der Wiederholungen (resp. Selbstaufrufe) ist bei rekursiver Programmierung manchmal weniger deutlich erkennbar. Beide Probleme mögen zu den berüchtigten [[Stapelüberlauf|Stapelüberläufen]] beitragen.
+* Im rekursiven Programmierstil lassen sich manche Szenarien nur durch eine sogenannte [[Rückruffunktion]] ({{enS|''callback function''}}) realisieren. Beispielsweise wird bei einer rekursiv programmierten [[Binärbaum#Traversierung|Traversierfunktion]] eines [[Binärbaum]]s dieser stets in seiner Gänze durchlaufen und die Nutzfunktion in einem Rückruf implementiert.<br/>Im Gegensatz dazu kann bei iterativer Programmierung das zu bearbeitende Segment des Baums durch eine [[Binärer Suchbaum#Suchen|Suchfunktion]] angesteuert, die Nutzfunktion nach Belieben als flache Anweisungsfolge bzw. als Unterprogramm implementiert und nach einem [[Binärbaum#Iterative Implementierung|(iterativen) Querschritt]] beim nächsten Element wiederholt werden.<ref>Siehe dazu [[Binärbaum#Traversierung|Traversierung]] (mit Codebeispielen) und Ben Pfaff: ''An Introduction to Binary Search Trees and Balanced Trees.'' Free Software Foundation, Inc. Boston 2004, S. 47 „4.9.2 Traversal by Iteration“.</ref>
+Mit wachsender Leistungsfähigkeit der Rechner tritt jedoch die Lesbarkeit und Wartbarkeit von Software gegenüber ihrer technischen Effizienz in den Vordergrund. Wo dies der Fall ist, bietet sich der rekursive Ansatz für die Arbeit mit [[baum]]artigen Datenstrukturen und der iterative für sequenzielle Datenstrukturen an.
 == Beispiel ==
-Ein Beispiel für die iterative Programmierung ist ein Datenbankdurchlauf ([[Pascal (Programmiersprache)|Pascal]]):
+Ein Beispiel für die iterative Programmierung ist ein Datenbankdurchlauf ([[Pascal (Programmiersprache)|Pascal]]) durch die Datensätze („Zeilen“) von (der „Tabelle“) <code>Dataset</code>:
-<syntaxhighlight lang="Pascal">
+<syntaxhighlight lang="pascal">
- procedure Durchlauf;
+procedure Durchlauf;
- begin
+begin
-  while not Dataset.Eof do
+    while not Dataset.Eof do                  ! wiederhole_solange Tabelle Dataset nicht „zu Ende“ ist
+    begin                                     ! den hier beginnenden Befehlsblock
-  begin
-   Befehl_1;
+        Befehl1;
-   Befehl_2;
+        Befehl2;
-   Befehl_3;
+        Befehl3;
+        Dataset.Next;                         !  Schalte weiter zum nächsten Datensatz (nächste „Zeile“) von Dataset.
-   Dataset.Next;
-  end;
+    end;
- end;
+end;
 </syntaxhighlight>
-Dabei werden Befehl_1, _2 und _3 solange wiederholt, bis alle [[Datensatz|Datensätze]] durchlaufen wurden.
+Dabei werden die Befehle 1 bis 3 solange wiederholt, bis alle [[Datensatz|Datensätze]] durchlaufen wurden.
 == Anmerkungen und Einzelnachweise ==