algo programmation structurée
This commit is contained in:
gwen
parent
428dc25db2
commit
11c43df090
|
|
@ -1,4 +1,4 @@
|
|||
Introduction à la modularité
|
||||
La programmation structurée
|
||||
=============================
|
||||
|
||||
Un langage de programmation doit permettre la programmation structurée.
|
||||
|
|
@ -21,54 +21,8 @@ Si on ne prend pas garde au bon découpage des programmes en modules indépendan
|
|||
on se retrouve rapidement débordé par un grand nombre de variables,
|
||||
et il devient quasiment impossible de réaliser un programme correct.
|
||||
|
||||
La modularité
|
||||
~~~~~~~~~~~~~
|
||||
|
||||
Les données et les traitements sont regroupés au sein d'une même entité à deux
|
||||
facettes : d'un côté le code proprement dit, de l'autre son interface. La
|
||||
communication entre modules s'effectue via leur interface. La description d'un
|
||||
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
|
||||
types de données abstraits facilitent les modifications d'implantation à
|
||||
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
|
||||
plus, les modules peuvent être paramétrés par d'autres modules augmentant
|
||||
ainsi leur réutilisabilité.
|
||||
|
||||
Le paradigme objet
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Les descriptions des traitements et des données sont regroupées dans des
|
||||
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
|
||||
La communication entre objets est réalisée par envoi de message, l'objet
|
||||
receveur détermine à l'exécution (liaison retardée) le traitement
|
||||
correspondant au message. En cela, la programmation objet est dirigée par
|
||||
les données. La structuration d'un programme provient des relations entre
|
||||
classes, en particulier l'héritage permet de définir une classe par extension
|
||||
d'une autre.
|
||||
|
||||
En programmation objet, un **programme** est une collection d’objets qui communiquent
|
||||
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
|
||||
|
||||
Comparaison entre les deux paradigmes
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Il y a dualité entre ces deux modèles.
|
||||
|
||||
- On ne peut pas augmenter les composants d'un type dans un module (pas
|
||||
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
|
||||
(extensibilité des traitements) sur ces données.
|
||||
|
||||
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
|
||||
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
|
||||
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
|
||||
|
||||
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
|
||||
traitements et les données.**
|
||||
|
||||
Sûreté d'exécution
|
||||
--------------------
|
||||
|
||||
La programmation raisonnée
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
---------------------------
|
||||
|
||||
Un **programme** est le codage d'un algorithme dans un langage de programmation.
|
||||
La programmation consiste à modéliser un problème du monde réel sous une forme
|
||||
|
|
@ -198,3 +152,49 @@ et l'implémentation effective de l'algorithme
|
|||
config_save_values(c, MODNAME)
|
||||
return True
|
||||
return False
|
||||
|
||||
Les deux grands paradigmes
|
||||
---------------------------
|
||||
|
||||
La modularité
|
||||
~~~~~~~~~~~~~~
|
||||
|
||||
Les données et les traitements sont regroupés au sein d'une même entité à deux
|
||||
facettes : d'un côté le code proprement dit, de l'autre son interface. La
|
||||
communication entre modules s'effectue via leur interface. La description d'un
|
||||
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
|
||||
types de données abstraits facilitent les modifications d'implantation à
|
||||
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
|
||||
plus, les modules peuvent être paramétrés par d'autres modules augmentant
|
||||
ainsi leur réutilisabilité.
|
||||
|
||||
Le paradigme objet
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Les descriptions des traitements et des données sont regroupées dans des
|
||||
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
|
||||
La communication entre objets est réalisée par envoi de message, l'objet
|
||||
receveur détermine à l'exécution (liaison retardée) le traitement
|
||||
correspondant au message. En cela, la programmation objet est dirigée par
|
||||
les données. La structuration d'un programme provient des relations entre
|
||||
classes, en particulier l'héritage permet de définir une classe par extension
|
||||
d'une autre.
|
||||
|
||||
En programmation objet, un **programme** est une collection d’objets qui communiquent
|
||||
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
|
||||
|
||||
Comparaison entre les deux paradigmes
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Il y a dualité entre ces deux modèles.
|
||||
|
||||
- On ne peut pas augmenter les composants d'un type dans un module (pas
|
||||
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
|
||||
(extensibilité des traitements) sur ces données.
|
||||
|
||||
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
|
||||
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
|
||||
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
|
||||
|
||||
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
|
||||
traitements et les données.**
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
Les modules
|
||||
============
|
||||
La programmation modulaire
|
||||
===========================
|
||||
|
||||
Il s'agit de décomposer un grand programme en
|
||||
morceaux (**modules**) connectés entre eux par des **interfaces** bien
|
||||
|
|
@ -240,3 +240,72 @@ obtenir un nouveau module :
|
|||
.. code-block:: ocaml
|
||||
|
||||
module M = F (Titi) (Toto)
|
||||
|
||||
|
||||
Signatures, type abstrait et langage de modules
|
||||
=================================================
|
||||
|
||||
Contrainte de type par signature
|
||||
------------------------------------
|
||||
|
||||
::
|
||||
|
||||
module M =
|
||||
struct
|
||||
type t = int * int * int ;;
|
||||
let make d m y = d, m, y ;;
|
||||
end ;;
|
||||
|
||||
let d = M.make 8 5 8 ;;
|
||||
|
||||
module type S =
|
||||
sig
|
||||
type t ;;
|
||||
val make : int -> int -> int -> t ;;
|
||||
end ;;
|
||||
|
||||
module MS = (M:S) ;;
|
||||
|
||||
MS.make 5 1 2 ;;
|
||||
|
||||
Type et signature
|
||||
------------------
|
||||
|
||||
::
|
||||
|
||||
# module type A = sig
|
||||
val a: int -> int
|
||||
end ;;
|
||||
module type A = sig val a : int -> int end
|
||||
# module B = struct
|
||||
let a x = x + 1 ;;
|
||||
end;;
|
||||
module B : sig val a : int -> int end
|
||||
# module C = (B:A) ;;
|
||||
module C : A
|
||||
|
||||
# C.a 2 ;;
|
||||
- : int = 3
|
||||
#
|
||||
|
||||
Module auquel on impose une signature
|
||||
-----------------------------------------
|
||||
|
||||
|
||||
::
|
||||
|
||||
module type DATE = sig
|
||||
type t
|
||||
val make: int -> t
|
||||
val get_year: t -> int
|
||||
val get_month: t -> int
|
||||
end ;;
|
||||
|
||||
module MR = struct
|
||||
type t = int * int
|
||||
let make x y = (x, y)
|
||||
let get_month (x, y) = x
|
||||
let get_year (x, y) = y
|
||||
end ;;
|
||||
|
||||
module date = (MR:DATE) ;;
|
||||
|
|
|
|||
|
|
@ -352,6 +352,17 @@ Il est possible de communiquer de la manière suivante avec un programme :
|
|||
- lire (du texte, un nombre...)
|
||||
- interagir avec les prompts
|
||||
|
||||
|
||||
.. code-block:: ocaml
|
||||
|
||||
let x = read_int () in
|
||||
let signe =
|
||||
if x >= 0
|
||||
then " positif "
|
||||
else " négatif " in
|
||||
print_string signe
|
||||
|
||||
|
||||
.. ifconfig:: exercice
|
||||
|
||||
**Exercice** : écrire un algorithme qui demande le prénom d'une personne
|
||||
|
|
|
|||
|
|
@ -0,0 +1,102 @@
|
|||
markup
|
||||
========
|
||||
|
||||
exercices
|
||||
---------
|
||||
|
||||
|
||||
.. ifconfig:: exercice
|
||||
|
||||
**Exercice** :
|
||||
|
||||
.. ifconfig:: correction
|
||||
|
||||
**Correction** :
|
||||
|
||||
|
||||
sphinx
|
||||
-----------
|
||||
|
||||
.. function:: spam(eggs)
|
||||
ham(eggs)
|
||||
|
||||
Spam or ham the foo.
|
||||
|
||||
The function :func:`spam` does a similar thing
|
||||
|
||||
|
||||
http://www.sphinx-doc.org/en/stable/markup/code.html
|
||||
|
||||
http://www.sphinx-doc.org/en/stable/domains.html
|
||||
|
||||
latex
|
||||
--------------
|
||||
|
||||
s'il faut mettre du latex :
|
||||
|
||||
https://www.jujens.eu/posts/2014/Aug/13/rapport-rst-sphinx/
|
||||
|
||||
(pour le preamble)
|
||||
|
||||
|
||||
.. role:: latex(raw)
|
||||
:format: latex
|
||||
|
||||
----
|
||||
|
||||
sudo apt-get install texlive-full
|
||||
|
||||
|
||||
You need to remove
|
||||
|
||||
\usepackage{algorithmicx}
|
||||
|
||||
and use the following in your preamble:
|
||||
|
||||
\usepackage{algorithm}% http://ctan.org/pkg/algorithms
|
||||
\usepackage{algpseudocode}% http://ctan.org/pkg/algorithmicx
|
||||
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\begin{algorithm}
|
||||
\caption{My algorithm}\label{euclid}
|
||||
\begin{algorithmic}[1]
|
||||
\Procedure{MyProcedure}{}
|
||||
\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}:
|
||||
\If {$\textit{string}(i) = \textit{path}(j)$}
|
||||
\State $j \gets j-1$.
|
||||
\State $i \gets i-1$.
|
||||
\State \textbf{goto} \emph{loop}.
|
||||
\State \textbf{close};
|
||||
\EndIf
|
||||
\State $i \gets
|
||||
i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
|
||||
\State \textbf{goto} \emph{top}.
|
||||
\EndProcedure
|
||||
\end{algorithmic}
|
||||
\end{algorithm}
|
||||
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\begin{algorithm}
|
||||
\caption{Euclid's algorithm}\label{euclid}
|
||||
\begin{algorithmic}[1]
|
||||
\Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
|
||||
\State $r\gets a\bmod b$
|
||||
\While{$r\not=0$}\Comment{We have the answer if r is 0}
|
||||
\State $a\gets b$
|
||||
\State $b\gets r$
|
||||
\State $r\gets a\bmod b$
|
||||
\EndWhile\label{euclidendwhile}
|
||||
\State \textbf{return} $b$\Comment{The gcd is b}
|
||||
\EndProcedure
|
||||
\end{algorithmic}
|
||||
\end{algorithm}
|
||||
Loading…
Reference in New Issue