175 lines
3.9 KiB
Markdown
175 lines
3.9 KiB
Markdown
### Exercice 1:
|
|
|
|
Programme xx;
|
|
var i : entier init à 0;
|
|
A[] : tableau init à 0;
|
|
|
|
procedure swap(x,y)
|
|
var z : entier;
|
|
|
|
debut
|
|
z := x;
|
|
x := y;
|
|
y := z;
|
|
fin
|
|
|
|
debut
|
|
i := 2;
|
|
A[2] := 99;
|
|
swap(i, A[i]);
|
|
fin
|
|
|
|
#### Q: Quel est l'effet de l'appel `swap(i, A[i]);`
|
|
|
|
1. Passage par valeur (`IN`)
|
|
2. ... / résultat (ADA)
|
|
3. ... / (ALGOLW)
|
|
4. ... par référence
|
|
5. ... par noms
|
|
|
|
|
|
**Notations:**
|
|
|
|
* `a := b` notation affectation algo
|
|
* `a `$\leftarrow$` b` notation affectation interne
|
|
|
|
#### Opérations d'affectation
|
|
|
|
|
|
`i := 2` (`i `$\leftarrow$` 2`);
|
|
|
|
`A[2] := 99` (`A[2] `$\leftarrow$` 99`)
|
|
|
|
|
|
|
|
|
|
##### 1) Passage par valeur
|
|
|
|
1. Execution de "IN" : Mettre la valeur dans les paramètres formels
|
|
* `x `$\leftarrow$` i` (`x `$\leftarrow$` 2`)
|
|
* `y `$\leftarrow$` A[2]` (`y `$\leftarrow$` 99`)
|
|
2. Execution du code
|
|
* `z := x;` (`z `$\leftarrow$` 2`)
|
|
* `x := y;` (`x `$\leftarrow$` 99`)
|
|
* `y := z;` (`y `$\leftarrow$` 2`)
|
|
|
|
##### 2) Passage par valeur/résultat (IN OUT ADA)
|
|
|
|
1. Calcul d'adressage
|
|
* $P_1$ ` = &i`
|
|
* $P_2$ ` = &A[i] = &A[2]`
|
|
2. Exécution du "IN"
|
|
* `x `$\leftarrow$` i` (`x `$\leftarrow$` 2`)
|
|
* `y `$\leftarrow$` A[2]` (`y `$\leftarrow$` 99`)
|
|
3. Exécution du code
|
|
* `z := x` (`z `$\leftarrow$` 2`)
|
|
* `x := y` (`x `$\leftarrow$` 99`)
|
|
* `y := z` (`y `$\leftarrow$` 2`)
|
|
4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs
|
|
* `i := 2` (`i `$\leftarrow$` 2`)
|
|
* `A[2] := 99` (`A[2] `$\leftarrow$` 99`)
|
|
* dans les paramètres effectifs **à travers le calcul d'adressage:**
|
|
* $P_1 \leftarrow$` x` (`i `$\leftarrow$` 99`)
|
|
* $P_2 \leftarrow$` y` (`A[2] `$\leftarrow$` 2`)
|
|
|
|
Conclusion : `i` et `A[2]` ont été échangés et permutés
|
|
|
|
##### 3) Passage par valeur/résultat (ALGOLW)
|
|
|
|
Mêmes étapes que `2)`, mais dans l'ordre suivant : b, c, a, d
|
|
|
|
##### 4) Passage de paramètre par référence
|
|
|
|
**Notation** : Pour une variable `x`, on appelle :
|
|
|
|
* `l.value` de `x`, son emplacement (adresse) _l(eft)_
|
|
* `r.value`, la valeur de `x` _r(ight)_
|
|
* mémo: `x := 10` (_left_ := _right_)
|
|
|
|
|
|
1. `l.value` de `x` est la même que celle de `i`
|
|
* `l.value` de `y` est la même que celle de `A[i]` c'est à dire `A[2]`
|
|
2. Exécution du code
|
|
* `z := x` (`z `$\leftarrow$` 2`)
|
|
* `x := y` (`x `$\leftarrow$` 99`)
|
|
* `y := z` (`A[2] `$\leftarrow$` 2`)
|
|
* **Conclusion:** `i` et `A[2]` on été permutés
|
|
|
|
|
|
##### 5) Passage pde paramètre par nom
|
|
|
|
1. Substitution des paramètres formels par les paramètres effectifs de manière textuelle **sans évaluation**
|
|
* `z := x` $\rightarrow$ `z `$\leftarrow$` i`
|
|
* `x := y` $\rightarrow$ `i `$\leftarrow$` A[i]`
|
|
* `y := z` $\rightarrow$ `A[i] `$\leftarrow$` z`
|
|
2. Exécution du code
|
|
* `z := i` (`z `$\leftarrow$` 2`
|
|
* `i := A[i]` (`i `$\leftarrow$` A[2] `$\leftarrow$` 99`)
|
|
* `A[i] := z` (`A[99] `$\leftarrow$` 2`)
|
|
3. **Conclusion:**
|
|
* `i` a été changé
|
|
* `A[2]` inchangé mais
|
|
* `A[99]` a été modifié
|
|
|
|
|
|
|
|
### Exercice 2
|
|
|
|
Procedure Quelmode(x)
|
|
A[1] := 6;
|
|
elt := 2;
|
|
x := x+3;
|
|
|
|
* A[1] := 1 (A[1] $\leftarrow$ 1)
|
|
* A[2] := 2 (A[2] $\leftarrow$ 2)
|
|
* elt := 1 (elt $\leftarrow$ 1)
|
|
|
|
##### 1) Appel par valeur
|
|
|
|
1. Exécution du `IN`
|
|
* x $\leftarrow$ A[elt] (x $\leftarrow$ A[1] $\leftarrow$ 1)
|
|
2. Exécution du code
|
|
* A[1] := 6 (A[1] $\leftarrow$ 6)
|
|
* elt := 2 (elt $\leftarrow$ 2)
|
|
* x := x+3 (x $\leftarrow$ 4)
|
|
3. **Conclusion:**
|
|
* A[1] $\leftarrow$ 6
|
|
* A[2] $\leftarrow$ 2
|
|
* elt $\leftarrow$ 2
|
|
|
|
##### 2) Par valeur/résultat (IN OUT ADA)
|
|
|
|
1. Calcul d'adressage
|
|
* $P_1$ ` = &A[1]`
|
|
2. Exécution du `IN`
|
|
* x <- A[1] (x <- 1)
|
|
3. Exécution du code
|
|
* A[1] := 6
|
|
* elt := 2
|
|
* x := x+3 (x <- 4)
|
|
4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs
|
|
* $P_1 \leftarrow $ A[1] (A[1] <- 4)
|
|
|
|
##### 3) Par valeur/résultat (ALGOLW)
|
|
|
|
|
|
### Exercice 3:
|
|
|
|
var elt : entier init à 1;
|
|
A[] : tableau d'entiers init à 0;
|
|
|
|
Procedure quelmdoe(x, y)
|
|
debut
|
|
elt := elt + 1;
|
|
A[x] := 5+elt;
|
|
y := y+A[x];
|
|
fin
|
|
|
|
Procedure Inc()
|
|
debut
|
|
elt := elt + 1;
|
|
|
|
return(elt);
|
|
fin
|
|
|