cours/paradigmesdeprogrammation/td/1.md

### 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