205 lines
5.3 KiB
Plaintext
205 lines
5.3 KiB
Plaintext
FIXME
|
||
======
|
||
|
||
Qu'est-ce qu'un programme ?
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
- Un programme est une suite de phrases
|
||
- Une phrase est une **déclaration** ou une **expression**.
|
||
- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
|
||
|
||
Les déclarations
|
||
----------------
|
||
|
||
Renseigner une variable
|
||
|
||
|
||
- en javascript :
|
||
|
||
.. code-block:: javascript
|
||
|
||
var b = "blabla" ;
|
||
|
||
- en python :
|
||
|
||
.. code-block:: python
|
||
|
||
b = "blabla"
|
||
|
||
- en java :
|
||
|
||
.. code-block:: java
|
||
|
||
String b = "A";
|
||
|
||
- en OCaml :
|
||
|
||
.. code-block:: ocaml
|
||
|
||
let a = 1
|
||
|
||
(**let** : soit `a` la variable... )
|
||
|
||
En OCaml comme dans tous les langages fonctionnels, toutes les "variables"
|
||
(les affectations) sont en fait des **constantes**.
|
||
|
||
.. important::
|
||
|
||
Par voie de conséquence, le symbole ``=`` est utilisé à la fois pour la définition des objets et pour le test d'égalité.
|
||
Pour les autres langages, on utilise `==` ou bien `===` (javascript) car
|
||
le `=` est sémantiquement déjà utilisé...
|
||
|
||
Toutes ces notation, apparemment anodines, correspondent donc à des paradigmes de programmation
|
||
|
||
Lorsqu'on ne déclare pas les types des symboles déclarés, c'est que soit
|
||
|
||
- le typage est faible
|
||
- le typage est dynamique (calcul du type en fonction du contenu de la
|
||
variable)
|
||
- le typage est statique et fort mais ça ne se voit pas
|
||
(var le système les calcule automatiquement par inférence de type)
|
||
|
||
Assigner, allouer, affecter une chose à quelqu'un ou à une autre chose.
|
||
|
||
Exemples dans la langue française :
|
||
|
||
- Le traitement que le budget **alloue** à ces fonctionnaires.
|
||
- Un système d'exploitation multitâche alloue le travail du processeur aux processus en attente, pour un bref laps de temps, à leur tour.
|
||
|
||
.. glossary::
|
||
|
||
|
||
affectation
|
||
|
||
une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
|
||
|
||
Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
|
||
comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
|
||
Dans certains langages, le symbole est considéré comme un opérateur d'affectation,
|
||
et la structure entière peut alors être utilisée comme une expression.
|
||
D'autres langages considèrent une affectation comme une instruction et ne permettent pas cet usage.
|
||
|
||
Voir aussi :
|
||
|
||
- Déclarations de types primitifs et conversions de type
|
||
- Tpes de base::
|
||
|
||
Octets (8 bits) byte
|
||
Entiers courts (16 bits) short
|
||
Entiers (32 bits) int
|
||
Entiers longs (64 bits) long
|
||
Réels (32 bits) float
|
||
Réels longs (64 bits) double
|
||
Caractères (16 bits) char
|
||
Booléens boolean
|
||
|
||
- Déclarations par lots::
|
||
|
||
x1 = e1, x2 = e2, ... xn = en;
|
||
|
||
Les fonctions
|
||
-------------
|
||
|
||
Préliminaire : rappel de théorie de l'information
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Théorie de l'information (Claude Shannon, 1949), théorie de la
|
||
communication
|
||
|
||
canal de transmission::
|
||
|
||
entrée -> récepteur -> émetteur -> sortie
|
||
|
||
Description d'une procédure
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
- une procédure peut prendre des paramètres
|
||
- elle modifie l'état courant du système
|
||
|
||
- Déclaration des paramètes
|
||
- Déclaration du corps
|
||
- Appel
|
||
|
||
procedure permuter(a: int, b:int)
|
||
z: int
|
||
begin
|
||
sdfdsfsdfsd
|
||
end
|
||
|
||
|
||
effet de bord
|
||
|
||
toute modification de la mémoire ou modification d'un support externe
|
||
|
||
instruction
|
||
|
||
command/phrase en mesure de modifier l'état du programme ou de la machine hôte
|
||
(allocation mémoire, support externe, disque, écran...)
|
||
|
||
Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
|
||
|
||
Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur
|
||
Cela permet de structurer le texte source du programme et améliorer sa
|
||
lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
|
||
dans le code, cette primitive.
|
||
|
||
.. **FIXME** : exemple avec un goto
|
||
|
||
Appel d'une procédure
|
||
~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
(ex: pseudo-pascal)
|
||
|
||
**déclaration de procédure**
|
||
|
||
::
|
||
|
||
procedure p(x1, ..., xn);
|
||
var v1,...,vm;
|
||
|
||
- les variables x1,...,xn sont appelées *paramètres formels* de p
|
||
- les variables v1,...,vm sont appelées *les variables locales* de p
|
||
|
||
**appel de procédure**
|
||
|
||
::
|
||
|
||
p(e1, ..., en)
|
||
|
||
les expressions e1,...,en sont appelées paramètres effectifs de p
|
||
|
||
::
|
||
|
||
program syracuse;
|
||
procedure syracuse(max : integer);
|
||
var i : integer;
|
||
procedure length();
|
||
var v,j : integer;
|
||
procedure step();
|
||
begin
|
||
v := v+1; if j = 2*(j/2) then j := j/2 else j := 3*j+1
|
||
end;
|
||
begin
|
||
v := 0; j := i; while j <> 1 do step(); writeln(v)
|
||
end;
|
||
begin
|
||
i := 1;
|
||
while i ≤ max do begin length(); i := i+1 end
|
||
end;
|
||
|
||
begin syracuse(100) end.
|
||
|
||
|
||
Le niveau d’une déclaration (de variable ou de procédure) est le nombre
|
||
de procédures sous lesquelles elle est déclarée. Le programme principal
|
||
a le niveau 0.
|
||
|
||
Description d'une fonction
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
|
||
en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
|
||
**toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)
|
||
|
||
|