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←b notation affectation interne

Opérations d'affectation

i := 2 (i←2);

A[2] := 99 (A[2]←99)

1) Passage par valeur

1. Execution de "IN" : Mettre la valeur dans les paramètres formels
   • x←i (x←2)
   • y←A[2] (y←99)
2. Execution du code
   • z := x; (z←2)
   • x := y; (x←99)
   • y := z; (y←2)

2) Passage par valeur/résultat (IN OUT ADA)

1. Calcul d'adressage
   • P₁ = &i
   • P₂ = &A[i] = &A[2]
2. Exécution du "IN"
   • x←i (x←2)
   • y←A[2] (y←99)
3. Exécution du code
   • z := x (z←2)
   • x := y (x←99)
   • y := z (y←2)
4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs
   • i := 2 (i←2)
   • A[2] := 99 (A[2]←99)
   • dans les paramètres effectifs à travers le calcul d'adressage:
     • P₁←x (i←99)
     • P₂←y (A[2]←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←2)
   • x := y (x←99)
   • y := z (A[2]←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 → z←i
   • x := y → i←A[i]
   • y := z → A[i]←z
2. Exécution du code
   • z := i (z←2
   • i := A[i] (i←A[2]←99)
   • A[i] := z (A[99]←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;

1) Appel par valeur

• A[1] := 1 (A[1] ← 1)
• A[2] := 2 (A[2] ← 2)
• elt := 1 (elt ← 1)

1. Exécution du IN
   • x ← A[elt] (x ← A[1] ← 1)
2. Exécution du code
   • A[1] := 6 (A[1] ← 6)
   • elt := 2 (elt ← 2)
   • x := x+3 (x ← 4)
3. Conclusion:
   • A[1] ← 6
   • A[2] ← 2
   • elt ← 2

2) Par valeur/résultat

1. Calcul d'adressage
   • P₁ = &A[1]
2. Exécution du IN