167 lines
4.4 KiB
Plaintext
167 lines
4.4 KiB
Plaintext
Les structures de contrôle
|
|
==========================
|
|
|
|
L'instruction de saut
|
|
----------------------
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple de saut conditionnel}\label{saut}
|
|
\begin{algorithmic}[1]
|
|
\Procedure{Euclide}{} \Comment{c'est l'algorithme d'Euclide}
|
|
\State $\textit{stringlen} \gets \text{length of }\textit{string}$
|
|
\State $i \gets \textit{patlen}$
|
|
\BState \emph{top}:
|
|
\If {$i > \textit{stringlen}$} \Return false
|
|
\EndIf
|
|
\State $j \gets \textit{patlen}$
|
|
\BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
|
|
\If {$\textit{string}(i) = \textit{path}(j)$}
|
|
\State $j \gets j-1$.
|
|
\State $i \gets i-1$.
|
|
\State \textbf{goto} \emph{loop}. \label{goto}
|
|
\State \textbf{close};
|
|
\EndIf
|
|
\State $i \gets
|
|
i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
|
|
\State \textbf{goto} \emph{top}. \Comment{C'est l'instruction de saut}
|
|
\EndProcedure
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
|
|
.. raw:: latex
|
|
|
|
Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
|
|
c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\
|
|
|
|
.. raw:: latex
|
|
|
|
Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\
|
|
|
|
Description générique d'une instruction de saut::
|
|
|
|
Instruction 1
|
|
Saut Label1
|
|
Instruction 2
|
|
...
|
|
Label1:
|
|
Instruction n
|
|
|
|
.. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
|
|
dans le langage cible, car c'est le meilleur moyen d'aboutir à
|
|
du **code spaghetti**.
|
|
|
|
L'instruction de branchement conditionnel
|
|
------------------------------------------
|
|
|
|
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non.
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple d'instruction de test}
|
|
\begin{algorithmic}[1]
|
|
\BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
|
|
\BState \emph{locale}: $a\gets ""$
|
|
\BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
|
|
\BState \emph{corps}:
|
|
\If{$quality\ge 9$}
|
|
\State $a\gets perfect$
|
|
\ElsIf{$quality\ge 7$}
|
|
\State $a\gets good$
|
|
\ElsIf{$quality\ge 5$}
|
|
\State $a\gets medium$
|
|
\ElsIf{$quality\ge 3$}
|
|
\State $a\gets bad$
|
|
\Else
|
|
\State $a\gets unusable$
|
|
\EndIf
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
|
|
L'instruction switch
|
|
--------------------
|
|
|
|
L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable.
|
|
Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable.
|
|
|
|
Les instructions d'itérations (boucles)
|
|
---------------------------------------
|
|
|
|
.. important:: Toutes les boucles concernent le paradigme de programmation impératif
|
|
et ne sont pas valides dans le paradigme de programmation fonctionnel
|
|
(puisque l'ordre d'évaluation importe)
|
|
|
|
- arrêt conditionnel (break)
|
|
- passage d'un pas (continue)
|
|
|
|
Répéter ... jusqu'à
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple de répéter ... jusqu'à}
|
|
\begin{algorithmic}[1]
|
|
\Require $i \gets 1$ \Comment{déclaration et initialisation de i}
|
|
\Statex
|
|
\Repeat \Comment{c'est le label de début du répéter}
|
|
\State $i \gets \textit{i+1}$
|
|
\Until{i == 100} \Comment{condition de fin de la boucle}
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
La boucle **pour** (for)
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple de boucle for}
|
|
\begin{algorithmic}[1]
|
|
\Require $sum\gets 0$
|
|
\Statex
|
|
\For{$i\gets 1, n$}
|
|
\State $sum\gets sum+i$
|
|
\EndFor
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
La boucle tant que (while)
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple de boucle while}
|
|
\begin{algorithmic}[1]
|
|
\Require $sum\gets 0$
|
|
\Statex
|
|
\State $i\gets 1$
|
|
\While{$i\le n$}
|
|
\State $sum\gets sum+i$
|
|
\State $i\gets i+1$
|
|
\EndWhile
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
Et les autres boucles : répéter... jusqu'à, etc...
|
|
|
|
.. raw:: latex
|
|
|
|
\begin{algorithm}
|
|
\caption{Exemple de boucle répéter}
|
|
|
|
\begin{algorithmic}[1]
|
|
\State $sum\gets 0$
|
|
\State $i\gets 1$
|
|
\Repeat
|
|
\State $sum\gets sum+i$
|
|
\State $i\gets i+1$
|
|
\Until{$i>n$}
|
|
\end{algorithmic}
|
|
\end{algorithm}
|