Control en subprogramas.

1. Control en subprogramas. Pelczer Ildikó Judit. Díaz Vera Alexei Eleusis. García Cárdenas Egar Arturo.

2. 1. Subprogramas o Rutinas.

3. •Los subprogramas o rutinas son unidades más pequeñas en las que se puede dividir un programa. •Procedimientos: Son rutinas que no regresan valor o regresan un valor vacío. •Funciones: Son rutinas que regresan un valor.

4. •Las rutinas se introducen mediante una declaración. •Las rutinas son descritas mediante una definición. •Las rutinas se activan mediante una invocación o llamada.

5. /*suma es un función que calcula la suma de los primeros n naturales 1+2+3+...+n; se supone que n es positivo*/ int suma(int n) { int i,s; s=0; for(i=1;i<=n;i++) s+=i; return s; }

6. •Alcance: Los elementos que pueden ser accesados por la rutina. •Local: Los elementos declarados dentro de ella. •No-local: Los elementos declarados independiente de ella. •Global: Los elementos visibles para todas las rutinas.

7. int A(int x, int y);//declaración de una función con dos //parámetros de tipo int con valor de //regreso int; A es visible a partir de este punto float B(int z) //Definición de la función B; //B es visible a partir de { //este punto int w,u; ... w=A(z,u); //se llama a A que en este punto ya es visible ... }; int A(int x, int y) //esta es la definicón de A { float t; ... t=B(x); //B es visible en este punto ... }

8. •Nombre: Se usa un encabezado que contiene: •El nombre del subprograma. •Los parámetros. •El valor de regreso (si hay). •Tipo: Se define por medio de la firma.

9. •L-value: Es el área de memoria donde se encuentra el código de la rutina. •R-value: Es una activación de la rutina.

10. int(*ps)(int);//esta línea declara que ps es un apuntador a //una rutina de tipo entero en C ps=&suma;//esta línea hace que ps apunte la rutina suma int i=(*ps)(5);//invoca el r-value de la rutina hacia la que //apunta ps

11. •La representación de una rutina en ejecución se llama instancia de la rutina, está compuesta por: •Bloque de código: •Registro de Activación: •Contiene información necesaria para la ejecución. •Espacio para las variables locales. •Un apuntador de regreso.

12. •Referencia ambiental de una instancia de una rutina: Consiste de todos los elementos locales y no-locales relacionados con los objetos dentro del registro de activación. •Local. •No-local.

13. •Parámetros formales: Son los que aparecen en la declaración de la rutina. •Parámetros reales: Son los que aparecen en la invocación a la rutina.

14. Procedure Ejemplo(A:T1;B:T2:=W;C:T3); --los parámetros A,B,C son de tipo T1, T2 y T3 --respectivamente; --un valor por omisión de B esá dado por W --las siguientes llamadas son legales si X, Y, Z y C son de --tipo T1, T2 y T3 respectivamente Ejemplo(X,Y,Z); --esta es asociación posicional Ejemplo(X,C=>Z); --X está asociado posicionalmente, --B toma el valor por omisión y --Z estáasociado con C explícitamente Ejemplo(C=>Z,A=>X,B=>Y);

15. 1.1. Rutinas Genéricas.

16. •Son machotes (templates) desde los cuales de una rutina general se pueden generar varias rutinas específicas.

17. template <class T> void swap(T& a, T& b) { T temp = a; a = b; b = temp; } void main() { int a=5, b=7; Complex c(1,0), d(4,5); swap(a,b); swap(c,d); }

18. 1.2. Alias y sobrecarga.

19. •Sobrecarga: Un mismo nombre para distintas entidades. •Una ocurrencia especifica del nombre debe proveersuficiente información para determinar la entidad de manera única. •Alias. Dos o más nombres se refieren a la misma entidad.

20. a=b+c+b();//ejemplo de sobrecarga a=b()+c+b(i);//otro ejemplo de sobrecarga int x=0; //en este ejemplo i y j se refieren a x int& i=x;// ycualquier modificación que se haga a int& j=x;//cualquiera de los tres afectará a los tres

21. 1.3. Un procesador semántico abstracto.

22. • SIMPLESEM es un procesador semántico abstracto, consta de: • Un apuntador de instrucción IP. • Una memoria dividida en dos partes C(Código) y D (Datos). C[X] y D[X] son los valores almacenados en las celdas X de C y D. X es un l-value y D[X] un r-value.

23. • Instrucciones: •set dirección, valor •jump dirección •jumpt dirección, condición •halt • Entrada –salida: write y read junto con la instrucción set. Se permiten usar operadores aritméticos y lógicos para calcular los distintos parámetros de las instrucciones.

24. 2. Estructura de tiempo de ejecución.

25. •De acuerdo a los requerimientos de memoria se tienen los siguientes tipos de lenguajes: •Lenguajes totalmente estáticos. •Lenguajes basados en pilas o stack. •Lenguajes dinámicos.

26. 2.1. Lenguajes con un solo enunciado simple.

27. •Hay solo una rutina principal que contiene la declaración de lo datos y las instrucciones que los manipulan. •Solo se tiene un registro de activación.

28. main() { int i,j; get(i,j); while(i!=j) if (i>j) i-=j; else j-=i; print(i); }

30. Ejemplo

31. 2.2. Lenguajes con rutinas simples.

32. •Se tiene un conjunto de declaraciones globales. •Un conjunto de declaraciones de rutinas. •Una rutina principal. •Las rutinas no están anidadas, no se pueden llamar a si mismas y no regresan valor.

33. •El tamaño de los registros de activación se conoce en tiempo de compilación. •Los registros de activación se asignan en memoria en tiempo de compilación. •El registro de activación consta de: •Dirección de regreso. •Espacio para las variables locales. •En compilación a cada variable se le asocia un desplazamiento.

34. • Varias implementaciones de FORTRAN y COBOL siguen este modelo.

37. Ejemplo

38. 2.3. Funciones recursivas.

39. •La recursión consiste en: •La habilidad que tienen los programas para llamarse a si mismos. •Directa. •Indirecta. •La capacidad de regresar valores.

40. •Se usa una estructura de Stack. •Para cada invocación de la rutina se crea un nuevo registro de activación. •Todas las instancias comparten el mismo código. •A cada variable se le asocia un desplazamiento en el correspondiente registro de activación.

41. •Se tiene que guardar la dirección del registro de activación actual, para enlazar las variables con su dirección. •Al momento de regreso se tiene que recuperar el registro de activación de la rutina invocadora. •En el registro de activación se coloca un espacio para la dirección de regreso y otro para la dirección base de la rutina invocadora, a este último se le llama liga dinámica.

42. •La cadena de ligas dinámicas a partir del último registro de activación es llamada la cadena dinámica. •Para colocar un nuevo registro de activación es necesario conocer la primera celda libre en el Stack. •La rutina invocadora extiende su registro de activación para reservar el espacio para el valor de regreso.

44. int n; int fact(int n) { if (n>1) return n*fact(n-1); else return 1; } main() { get(n); if (n>=0) print(fact(n)); }

45. Ejemplo

46. 2.4. Estructura de bloques.

47. •Sirve para controlar el alcance y tiempo de vida de las variables. •Divide el programa en unidades más pequeñas. •Dos bloques pueden ser ajenos o anidados.

48. 2.4.1. Anidamiento por enunciados compuestos.

49. •Las variables localmente declaradas en un enunciado compuesto son visibles en el y en los enunciados compuestos inmersos. •Las declaraciones internas enmascaran a las externas con el mismo nombre. •Se define también el tiempo de vida de las variables locales, la variable se enlaza a un espacio en memoria mientras el bloque está activo.

50. •Una estructura de bloque se puede describir por medio de un árbol sintáctico de anidamiento. •En el registro de activación de una rutina se asigna espacio suficiente para todas las variables. •Dos bloques ajenos no pueden estar activos al mismo tiempo. •Se puede usar el mismo espacio en memoria para variables distintas en bloques ajenos (overlay).