Iterative Programmierung - Versionsgeschichte

Squasher: Interwikilink korrigiert

2023-12-19T20:43:59Z

Interwikilink korrigiert

← Nächstältere Version		Version vom 19. Dezember 2023, 22:43 Uhr
Zeile 1:		Zeile 1:
	Die '''~~[[:wikt:iterativ\|~~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.		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.

	== Abgrenzung ==		== Abgrenzung ==

Matthäus Wander: link

2023-08-19T14:12:20Z

link

← Nächstältere Version		Version vom 19. August 2023, 16:12 Uhr
Zeile 7:		Zeile 7:

	=== Gegenüberstellung ===		=== Gegenüberstellung ===
	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]]n führen können.		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:		Iterative Implementierungen bieten oft Vorteile:

DixMartin: +Links

2021-06-11T21:27:57Z

+Links

← Nächstältere Version		Version vom 11. Juni 2021, 23:27 Uhr
Zeile 12:		Zeile 12:
	* 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>		* 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.		* 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ärbaums~~ 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>		* 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 ~~baumartigen~~ Datenstrukturen und der iterative für sequenzielle Datenstrukturen an.		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 ==		== Beispiel ==

Idohl: Abbruch: Beschränkung auf Normalfall (Abweichungen in betreffenden Artikel verschoben)

2021-04-25T11:25:12Z

Abbruch: Beschränkung auf Normalfall (Abweichungen in betreffenden Artikel verschoben)

← Nächstältere Version		Version vom 25. April 2021, 13:25 Uhr
Zeile 7:		Zeile 7:

	=== Gegenüberstellung ===		=== Gegenüberstellung ===
	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]]n führen können. Es gibt jedoch auch Programme mit absichtlichen Endlosschleifen, bspw. [[Ereignisschleife]]n ({{enS\|event loop}} oder {{lang\|en\|''message dispatcher''}}), darunter solche, die ohne [[aktives Warten]] auskommen.		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]]n führen können.

	Iterative Implementierungen bieten oft Vorteile:		Iterative Implementierungen bieten oft Vorteile:

Nomen4Omen: /* Gegenüberstellung */ s. Disku

2021-04-24T15:02:23Z

Gegenüberstellung: s. Disku

← Nächstältere Version		Version vom 24. April 2021, 17:02 Uhr
Zeile 7:		Zeile 7:

	=== Gegenüberstellung ===		=== Gegenüberstellung ===
	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 ~~einen~~ ~~sogenannten~~ ~~Selbstaufruf~~ der betreffenden Funktion, ~~die~~ ~~dadurch~~ ~~(bei~~ [[~~Endrekursion~~]]) ~~unendlich~~ ~~oft~~ ~~ausgeführt~~ ~~werden~~ ~~könnte.~~ Um ~~eine~~ ~~endliche~~ ~~Anzahl~~ ~~Wiederholungen~~ zu ~~erreichen,~~ ~~benötigt~~ ~~das~~ ~~Programm~~ ~~ebenso~~ ~~eine~~ [[~~Abbruchbedingung~~]] (~~oder~~ ~~einen~~ ~~nichtrekursiven~~ ~~Ausführungszweig~~) ~~wie~~ die ~~Schleife~~ ~~bei~~ ~~der~~ ~~iterativen Programmierung~~.		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]]n führen können. Es gibt jedoch auch Programme mit absichtlichen Endlosschleifen, bspw. [[Ereignisschleife]]n ({{enS\|event loop}} oder {{lang\|en\|''message dispatcher''}}), darunter solche, die ohne [[aktives Warten]] auskommen.

	Iterative Implementierungen bieten ~~jedoch~~ oft Vorteile:		Iterative Implementierungen bieten oft Vorteile:
	* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver bei jedem Selbstaufruf der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann ~~(beachte~~ ~~Sonderfall~~ [[Endrekursion]]).		* 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, ~~wovon~~ die berüchtigten [[Stapelüberlauf\|~~Stapelüberläufe~~]] ~~eine Folge sind~~. ~~(Dito Endrekursion)~~		* 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 ~~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.<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>		* 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ärbaums 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 baumartigen Datenstrukturen und der iterative für sequenzielle Datenstrukturen an.		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.

Arilou: /* Gegenüberstellung */ einige Vorteile bestehen nicht gegenüber endrekursiven Funktionen

2021-04-21T07:54:59Z

Gegenüberstellung: einige Vorteile bestehen nicht gegenüber endrekursiven Funktionen

← Nächstältere Version		Version vom 21. April 2021, 09:54 Uhr
Zeile 10:		Zeile 10:

	Iterative Implementierungen bieten jedoch oft Vorteile:		Iterative Implementierungen bieten jedoch oft Vorteile:
	* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver bei jedem Selbstaufruf ~~unvermeidlich~~ der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann.		* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver bei jedem Selbstaufruf der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann (beachte Sonderfall [[Endrekursion]]).
	* 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.		* 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. (Dito Endrekursion)
	* 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.<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>		* 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.<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 baumartigen Datenstrukturen und der iterative für sequenzielle Datenstrukturen an.		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.

Arilou: Die Einleitung sollte sich mit dem Artikelthema befassen, und nicht stark überwiegend (hier 3/4) mit dem Gegenteil, v.a. wenn's sowieso ein extra Kapitel dafür gibt.

2021-04-21T07:51:22Z

Die Einleitung sollte sich mit dem Artikelthema befassen, und nicht stark überwiegend (hier 3/4) mit dem Gegenteil, v.a. wenn's sowieso ein extra Kapitel dafür gibt.

← Nächstältere Version		Version vom 21. April 2021, 09:51 Uhr
Zeile 1:		Zeile 1:
	Die '''[[:wikt:iterativ\|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.		Die '''[[:wikt:iterativ\|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.

	Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] 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 einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.

	== Abgrenzung ==		== Abgrenzung ==
Zeile 9:		Zeile 7:

	=== Gegenüberstellung ===		=== Gegenüberstellung ===
	In der Literatur werden Funktionen gerne im [[Rekursive Programmierung\|rekursiven Programmierstil]] vorgestellt, die meist als einfacher zu verstehen gelten. ~~Iterative~~ ~~Varianten~~ ~~bieten~~ ~~jedoch~~ ~~oft~~ ~~Vorteile~~:		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 einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] (oder einen nichtrekursiven Ausführungszweig) wie die Schleife bei der iterativen Programmierung.

			Iterative Implementierungen bieten jedoch oft Vorteile:
	* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver bei jedem Selbstaufruf unvermeidlich der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann.		* Bei iterativer Programmierung kann der Speicherbedarf schärfer durch den Programmierer zugeschnitten und kontrolliert werden, wogegen bei rekursiver bei jedem Selbstaufruf unvermeidlich der Kontext der aufrufenden Prozedur (im Programm-Stapelspeicher) zu retten ist, damit er beim [[Rücksprung]] wieder hergestellt werden kann.
	* 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.		* 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.

Aka: Punkt vor und nach Ref-Tag korrigiert

2021-04-20T18:29:06Z

Punkt vor und nach Ref-Tag korrigiert

← Nächstältere Version		Version vom 20. April 2021, 20:29 Uhr
Zeile 1:		Zeile 1:
	Die '''[[:wikt:iterativ\|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.		Die '''[[:wikt:iterativ\|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.

	Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] 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 einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.		Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] 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 einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.

	== Abgrenzung ==		== Abgrenzung ==

Idohl: - überflüss. Rest

2021-04-20T16:02:16Z

- überflüss. Rest

← Nächstältere Version		Version vom 20. April 2021, 18:02 Uhr
Zeile 1:		Zeile 1:
	Die '''[[:wikt:iterativ\|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.		Die '''[[:wikt:iterativ\|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.

	Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] die Wiederholung erreicht, ohne dass das Programm explizite Schleifen enthält.<ref> [[Niklaus Wirth]]: ''Algorithmen und Datenstrukturen'', [[B. G. Teubner]] 1983, Seite 150</ref>~~. indem ein [[Rekursion\|rekursiver]] Vorgang inganggesetzt wird~~. Anstatt Schleifenkontrollanweisungen ~~e3nthält~~ das Programm einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.		Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] 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 einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.

	== Abgrenzung ==		== Abgrenzung ==

Idohl: + EN für: ohne dass das rek. Programm explizite Schleifen enthält.

2021-04-20T16:00:08Z

+ EN für: ohne dass das rek. Programm explizite Schleifen enthält.

← Nächstältere Version		Version vom 20. April 2021, 18:00 Uhr
Zeile 1:		Zeile 1:
	Die '''[[:wikt:iterativ\|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.		Die '''[[:wikt:iterativ\|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.

	Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] die Wiederholung erreicht, ~~indem~~ ~~ein~~ [[~~Rekursion\|rekursiver~~]] ~~Vorgang~~ ~~inganggesetzt~~ ~~wird:~~ ~~Zusätzlich~~ ~~zum~~ [[~~Blockstruktur~~\|~~Anweisungsblock~~]] wird ~~anstatt~~ ~~der~~ Schleifenkontrollanweisungen ~~ein~~ ~~sogenannter~~ Selbstaufruf der betreffenden Funktion ~~durchgeführt~~, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.		Im Unterschied dazu wird bei [[rekursive Programmierung\|rekursiver Programmierung]] die Wiederholung erreicht, ohne dass das Programm explizite Schleifen enthält.<ref> [[Niklaus Wirth]]: ''Algorithmen und Datenstrukturen'', [[B. G. Teubner]] 1983, Seite 150</ref>. indem ein [[Rekursion\|rekursiver]] Vorgang inganggesetzt wird. Anstatt Schleifenkontrollanweisungen e3nthält das Programm einen sogenannten Selbstaufruf der betreffenden Funktion, die dadurch (bei [[Endrekursion]]) unendlich oft ausgeführt werden könnte. Um eine endliche Anzahl Wiederholungen zu erreichen, benötigt das Programm ebenso eine [[Abbruchbedingung]] wie die Schleife bei der iterativen Programmierung.

	== Abgrenzung ==		== Abgrenzung ==