Démo du 10 février 2003 1) Procédures surdéfinies. Le langage hypothétique Lmnop fournit la possibilité de créer des procédures surdéfinies. Supposons que les types sont: `char', `int' et `float'. En cas de besoin, Lmnop convertit automatiquement les paramètres entre les types `int' et `float', mais pas entre `char' et un des deux autres types. Les règles utilisées sont comme en pp. 131-132 sauf qu'il n'y a pas de concept de "promotion". La fonction f est (sur)définie comme suit: int f(char a, int b, int c); /* V.1 */ int f(float a, int b, float c); /* V.2 */ int f(float a, float b, int c); /* V.3 */ Que se passe-t-il avec ces appels? a) f('a', 4, 'b') b) f(1.2, 3.4, 11) c) f(6.34, 2.96, -8.99) d) f(76, 12, 5.2) e) f(18.3, 'c', 1) f) f('d', 9, 0.4) g) f(6, 5, 4) 2) Activation: cas non-récursif. Tracer le programme suivant (version sans procédure). Programme Pascal en C sans procédure program non_recursif; | int x; | var x : integer; | int abs_n, abs_res; | void *abs_ret; function abs(n:integer) | : integer; | int max_m, max_n, max_res; begin | void *max_ret; abs := n; | if n<0 then abs := -n; | void non_recursif() end; | { | max_m = 4; function max(m,n:integer) | max_n = 6; : integer; | max_ret = &&point1; begin | goto max; max := (m+n+abs(m-n))/2; | point1: end; | x = max_res; | printf("%d\n",x); begin | return; x := max(4,6); | writeln(x); | abs: end. | abs_res = abs_n; | if (abs_n<0) | abs_res = -abs_n; | goto *abs_ret; | | max: | abs_n = max_m-max_n; | abs_ret = &&point2; | goto abs; | point2: | max_res = | (max_m+max_n+abs_res)/2; | goto *max_ret; | } 3) Activation: cas récursif. Tracer le programme suivant (version sans procédure). Noter que la version utilise une variable temporaire car `fib' fait 2 appels récursifs à `fib'. Programme Pascal en C sans procédure program recursif; | typedef struct BLOC | { int n, tmp; var x : integer; | void *ret; | struct BLOC *dyn; function fib(n:integer) | } bloc; : integer; | begin | bloc *bac, *p; if n<2 then | int x; fib := n | int fib_res; else | fib := fib(n-1) | void recursif() +fib(n-2); | { bac = NULL; end; | | p = (bloc*)malloc(sizeof(bloc)); begin | p->n = 2; x := fib(2); | p->ret = &&point1; writeln(x); | p->dyn = bac; end. | bac = p; | goto fib; | point1: | p = bac->dyn; | free(bac); | bac = p; | x = fib_res; | printf("%d\n",x); | return; | | fib: | if (bac->n<2) | fib_res = bac->n; | else | { p = (bloc*)malloc(sizeof(bloc)); | p->n = bac->n-1; | p->ret = &&point2; | p->dyn = bac; | bac = p; | goto fib; | point2: | p = bac->dyn; | free(bac); | bac = p; | bac->tmp = fib_res; | p = (bloc*)malloc(sizeof(bloc)); | p->n = bac->n-2; | p->ret = &&point3; | p->dyn = bac; | bac = p; | goto fib; | point3: | p = bac->dyn; | free(bac); | bac = p; | fib_res = bac->tmp+fib_res; | } | goto *bac->ret; | }