Patrons de conception/Interpréteur
Le patron de conception Interpréteur est utilisé pour des logiciels ayant besoin d'un langage afin de décrire les opérations qu'ils peuvent réaliser (exemple : SQL pour interroger une base de données).
Le modèle de conception Interpréteur définit la grammaire de ce langage et utilise celle-ci pour interpréter des états dans ce langage.
Ce patron de conception est très utile dans deux cas:
Ce patron définit comment interpréter les éléments du langage.
Dans ce patron de conception, il y a une classe par symbole terminal et non-terminal du langage à interpréter.
L'arbre de syntaxe du langage est représenté par une instance du patron de conception Objet composite.
Diagramme de classes.
Le patron de conception Interpréteur peut être représenté par le diagramme de classes suivant :
Exemples.
Java.
L'exemple Java suivant montre comment interpréter un langage spécialisé, tel que les expressions en notation polonaise inversée. Dans ce langage, on donne les opérandes avant l'opérateur.
import java.util.*;
interface Expression
 public void interpret(Stack<Integer> s);
class TerminalExpression_Number implements Expression
 private int number;
 public TerminalExpression_Number(int number)
 public void interpret(Stack<Integer> s)
class TerminalExpression_Plus implements Expression
 public void interpret(Stack<Integer> s)
class TerminalExpression_Minus implements Expression
 public void interpret(Stack<Integer> s)
class Parser
 private ArrayList<Expression> parseTree =
 new ArrayList<Expression>(); // only one NonTerminal Expression here
 public Parser(String s)
 for (String token : s.split(" "))
 if (token.equals("+"))
 parseTree.add( new TerminalExpression_Plus() );
 else if (token.equals("-"))
 parseTree.add( new TerminalExpression_Minus() );
 else
 parseTree.add( new TerminalExpression_Number(Integer.parseInt(token)) );
 public int evaluate()
 Stack<Integer> context = new Stack<Integer>();
 for (Expression e : parseTree) e.interpret(context);
 return context.pop();
class InterpreterExample
 public static void main(String[] args)
 String expression = "42 4 2 - +";
 Parser p = new Parser(expression);
 System.out.println("'" + expression +"' equals " + p.evaluate());
Ce programme affiche : 
 '42 4 2 - +' equals 44

Patrons de conception/Itérateur
L'itérateur est un patron de conception comportemental.
Un itérateur est un objet qui permet de parcourir tous les éléments contenus dans un autre objet, le plus souvent un conteneur (liste, arbre, etc.). Un synonyme d'itérateur est curseur, notamment dans le contexte des bases de données.
Description.
Un itérateur ressemble à un pointeur disposant essentiellement de deux primitives : "accéder" à l'élément pointé en cours (dans le conteneur), et "se déplacer" pour pointer vers l'élément suivant.
En sus, il faut pouvoir créer un itérateur pointant sur le premier élément ; ainsi que déterminer à tout moment si l'itérateur a épuisé la totalité des éléments du conteneur.
Diverses implémentations peuvent également offrir des comportements supplémentaires.
Le but d'un itérateur est de permettre à son utilisateur de "parcourir" le conteneur, c'est-à-dire d'accéder séquentiellement à tous ses éléments pour leur appliquer un traitement, tout en isolant l'utilisateur de la structure interne du conteneur, potentiellement complexe.
Ainsi, le conteneur peut stocker les éléments de la façon qu'il veut, tout en permettant à l'utilisateur de le traiter comme une simple liste.
Le plus souvent l'itérateur est conçu en même temps que la classe-conteneur qu'il devra parcourir, et ce sera le conteneur lui-même qui créera et distribuera les itérateurs pour accéder à ses éléments.
Différences avec l'indexation.
Dans les langages procéduraux on utilise souvent un index dans une simple boucle, pour accéder séquentiellement à tous les éléments, notamment d'un tableau.
Quoique cette approche reste possible en programmation objet pour certains conteneurs, l'utilisation des itérateurs a certains avantages :
Important : il est indispensable de bien consulter la documentation d'un itérateur pour savoir dans quels cas il est invalidé ou non.
La possibilité pour un conteneur de se voir modifié pendant une itération s'est imposée comme nécessaire dans la programmation objet moderne, où les relations entre objets et l'effet de certaines opérations peut devenir un casse-tête.
En utilisant un tel itérateur « robuste », ces désagréments nous sont épargnés.
Utilisation d'un itérateur explicite.
Dans un langage à objets comme le C#, un itérateur est un objet qui implémente l'interface IEnumerator.
interface IEnumerator
 void Reset();
 bool MoveNext();
On utilise l'itérateur pour accéder aux valeurs disponibles.
IterateurTypique iterateur = new IterateurTypique ();
iterateur.Reset(); // optionnel : cet appel peut ne pas être effectué.
while(iterateur.MoveNext())
 Console.WriteLine(iterateur.Current);
Une des nombreuses implémentations de l'objet possibles peut ressembler à celle-ci.
class IterateurTypique : IEnumerator
 private string[] _chainesAParcourir = new string[] { "TF1", "France2", "FR3", "Canal+" };
 private int _positionCourante = -1;
 public void Reset()
 public bool MoveNext()
 if( _positionCourante + 1 >= _chainesAParcourir.Length ) return false;
 _positionCourante +=1;
 return true;
 public object Current
L'interface IEnumerable de C# permet le passage à un itérateur implicite. 
interface IEnumerable
 IEnumerator GetEnumerator();
les tableaux, listes ou dictionnaires de C# sont des types dérivés de IEnumerable et possèdent une méthode GetEnumerator() qui appelle l'itérateur explicite.
l'instruction foreach du C# appelle cette méthode GetEnumerator() et procède à une itération explicite tout en cachant les détails de l'implémentation.
if(Television is IEnumerable)
 foreach(object chaine in Television)
 Console.WriteLine(chaine);
Itérateurs implicites.
Des langages à objets comme Perl et Python fournissent un moyen « interne » d'itérer sur les éléments d'un conteneur sans introduire explicitement un itérateur.
Cela est souvent implémenté par une structure de contrôle "for-each", comme dans les exemples suivants :
foreach val $list {
 puts stdout $val
foreach $val (@list) {
 print "$val\n";
for Value in List:
 print Value
// PHP, itérateur implicite
foreach ($list as $value)
 print $value;
// Java, J2SE 5.0, itérateur implicite
for (Value v : list)
 System.out.print(v);
// C#, itérateur implicite
foreach (object obj in list)
 Console.WriteLine(obj );
// C#, itérateur explicite avec un yield
foreach (object obj in IndicesPairs() )
 Console.WriteLine(obj);
// ou IndicesPairs() est une méthode
IEnumerable IndicesPairs()
 for(int i=0; i<tableau.Length; i++)
 if(i%2==0)
 yield return tableau[i];
list.each do |value|
 puts value
end
def each
 for i in 0...size
 yield(self[i])
 end
end
Attention, en Javascript, on itère pas directement sur les objets mais sur leur nom
// Javascript, itérateur implicite
for(nom in Object)
 var valeur = Object[nom];
 alert(Value+" = "+valeur ]);
Le langage C++ dispose également de la fonction template codice_1 qui permet des itérations implicites similaires, mais requiert toujours de fournir des objets itérateurs en paramètres d'entrée.
"Remarque : le Ruby (ainsi que le C# à partir de sa version 2.0), offre via yield un outil spécifique pour construire des itérateurs. "