Notions de paramètres (algorithme)

bien le salut a vous
voila je suis sur un cour concernant les actions en algorithmes et j'ai du mal a assimilé la notions parametres telque précisé dans le cours:

trois catégories de paramètres :

1) Les paramètres d’entrée : valeur fournie par l’action appelante et utilisée par l’action appelée.

2) Les paramètres de sorties : valeurs calculées par l’appelée et transmises vers l’appelante.

3) Paramètres d’entrée/sorties : valeurs fournies par l’appelante, modifiées par l’appelée et renvoyés à l’appelée.

quelqu'un peut il m'expliqué svp c trois catégories?
amicalement adel

Je tente de t'expliquer ;)

Si tu veux créer une fonction ADDITION
elle demande 2 paramètres en entrée (a,b)
et le résultat en sortie est
la somme de tes 2 paramètres en entrée

ex :

Code:

---

1 2 3 4 5

var a,b,c a <- 1 b <- 2   c <- ADDDITION (a,b)

---

dans c il y aura ... 3, les valeurs de a (1) et b (2) n'ont pas bougé


si tu veux créer une fonction increment INC
elle demande 1 paramètre en entrée et le résultat en sortie est
le paramètre en entrée +1

là 2 solutions

ex1 :

Code:

---

1 2 3

var i,j i <- 1 j <- INC(i)

---

dans j il y aura 2, la valeur de i (1) n'a pas bougé

Maintenant on peut aussi imaginer mettre le paramètre de la fonction INC
en entrée / sortie et programmer de telle manière
que chaque fois qu'on appelera la fonction INC le paramètre en entrée/ sortie
sera incrémenté de 1
Appelons cette nouvelle fonction INCA

ex:

Code:

---

1 2 3 4

var i i <- 1 Si INCA(i) = 2 alors ecrire "valeur de i est à 2" sinon ecrire "Ah non !?"

---

Dans notre cas on aura en résultat "valeur de i est à 2"

Note :

voici le contenu de la fonction INC
=>

Code:

---

1 2 3 4 5 6

INC ( variable i en Entrée) Debut var ret ret <- i+1 retourner ret Fin

---

voici le contenu de la fonction INCA
=>

Code:

---

1 2 3 4

INCA ( variable i en Entrée/Sortie) Debut i <- i+1 Fin

---

Ok ?

donc je dois considéré le cas des des parametres d'entré dans le premier exemple c ca ?
les valeur a et b sont fournie par l'action appelante et utilisé par l'action appelé.
une autre question :
les parametre es-ce-qu'ils peuvent etre considéré comme etant des variables ?
enfin si tu veux bien refaire l'exemple par ordre 1,2,3 pour que ca soit bien clair;)

Je pense qu'il faudrait quelques détails supplémentaires...
Parce que ce que moi j'appelle "paramètres", c'est uniquement les valeurs passés à une procédure dans sa liste de paramètres.

Autrement dit, paramètre pour moi, c'est :
Dans une définition :

Code:

---

1 2 3

Proc Addition(a, b) Return (a + b) End

---

la liste de paramètres est (a, b) et "a" et "b" sont des paramètres de la procédure addition.

Dans un appel de procédure :

Code:

---

1 2 3 4 5 6

Var debut, longueur, fin   debut <- 3 longueur <- 5   fin <- Addition( debut, longueur )

---

Ici pour moi, fin n'est pas un paramètre, par contre debut et longueur sont des paramètres passés à Addition(), ce sont des "paramètres d'entrée" puisqu'ils apportent des valeurs de l'appelant à l'appelé et ne sont pas modifiés par Addition().

Maintenant supposons que Addition soit plutôt défini comme cela :

Code:

---

1 2 3

Proc Addition(a, b, c) c <- (a + b) End

---

Alors a, b et c sont des paramètres, a et b sont des paramètres d'entrée, c est un paramètre de sortie.

Code:

---

1 2 3 4 5 6

Var debut, longueur, fin   debut <- 3 longueur <- 5   Addition( debut, longueur, fin )

---

Contrairement au code précédent, fin est aussi un paramètre, mais un paramètre de sortie.

On pourrait également définir addition comme cela :

Code:

---

1 2 3

Proc Addition(a, b) a <- (a + b) End

---

Dans ce cas, a et b sont les paramètres, a est un paramètre d'entrée/sortie et b est un paramètre d'entrée.

Utilisée ainsi :

Code:

---

1 2 3 4 5 6 7 8 9

Var debut, longueur, chaine debut <- 0 longueur <- 2 chaine <- "Ce n'est qu'un au revoir."   While debut < Longueur(chaine) Do Afficher(SousChaine(chaine, debut, longueur)) Addition( debut, longueur) Done

---

On affichera la chaine par tronçon de 2 caractères.
Ici debut et longueur sont des paramètres de SousChaine en tant que paramètres d'entrée (ainsi que chaine), mais ils sont également paramètres de Addition, debut en tant que paramètres d'entrée/sortie et longueur en tant que paramètre d'entrée.


Confus ? Cela te semble-t-il inutilement complexe ? En tout cas, pour moi c'est le cas, c'est l'une des raisons pour lesquelles je préfère les langages fonctionnels comme Haskell, qui n'ont qu'un seul type de paramètre : le paramètre d'entrée.

--
Jedaï

Salut!
Il faut prendre garde à un point qui dépend du langage. Le Fortran connait deux sortes de sous-programmes, les fonctions et les routines: il est donc possible d'écrire une fonction qui a deux paramètres (d'entrée) a et b et qui retourne la somme, ou une routine qui a trois paramètres, deux d'entrée comme précédemment et un de sortie pour la somme. D'autres langages ne connaissent pas les routines.
Jean-Marc Blanc

Citation:

---

D'autres langages ne connaissent pas les routines.

---

A part prolog (qui ne connait même pas les fonctions sauf à valeurs logiques, les prédicats) je n'en connais pas. Peux tu donner des exemples ?
NB: Ne pas jouer sur les mots pour moi routine = procédure = fonction void.

Alors Adel01

C'est plus clair pour toi après
ces multiples explications ?

Il y a un vocabulaire précis. On distingue les paramètres formels (ceux que l'on utilise pour spécifier une fonction) des paramètres effectifs (ceux que l'on passe à l'appel d'une fonction). Au moment de la specification, à chaque paramètre formel peut être associé un mode IN, OUT et parfois IN/OUT. Ce mode détermine typiquement un passage par valeur ou par adresse.