Elementos de programación

UNIVERSIDAD DE MALAGA
DPTO. DE LENGUAJES Y C. DE LA COMPUTACION
E.T.S. DE INGENIERIA INFORMATICA
INGENIERIA INFORMATICA
ELEMENTOS DE PROGRAMACION I
(CURSO 2000-2001)
CRITERIOS GENERALES
DE ESTILO
EN PROGRAMACIÓN
&5,7(5,26*(1(5$/(662%5(
(/(67,/2(1352*5$0$&,Ï1
Para obtener buenos programas no basta con escribir un determinado código y comprobar que
funciona. Es muy probable que, por muy diversas razones, dichos programas deban ser modificados en el
futuro. Por ello, un buen programador no se debe conformar con que un programa aparentemente funcione,
sino que debe preocuparse de que cumpla una serie de requisitos que faciliten futuras modificaciones y/o la
búsqueda y corrección de errores. Dichos requisitos podrían ser divididos en dos categorías. En una estarían
aquellos requisitos provenientes de la necesidad de aplicar correctamente los principios básicos de la
programación (modularización, diseño descendente, etc), a lo que podríamos denominar HVWLORGHGLVHxR. En
la otra estarían aquellos requisitos necesarios para conseguir que la presentación del programa favorezca su
legibilidad (documentación, sangrado, etc), a lo que podríamos denominar HVWLORGHSUHVHQWDFLyQ.
Este documento se ha elaborado con la intención de resaltar la importancia de tener en cuenta
DPERV DVSHFWRV a la hora de desarrollar un programa. Para ello, en primer lugar se resumirán aquellos
aspectos básicos que podrían configurar lo que hemos denominado estilo de diseño, y posteriormente se hará
hincapié en los principales puntos que conducen a disponer de programas con un adecuado estilo de
presentación.
Es imprescindible que el alumno aplique correctamente todos los principios básicos de
programación que contribuyen a un buen diseño de programas. Sin embargo, no se exigirá que el alumno
aplique exactamente el estilo de presentación que se propondrá más adelante, aunque sí se exigirá que el
estilo aplicado a los programas cumpla unas normas básicas que doten al texto obtenido de una mínima
coherencia y legibilidad.
Se recomienda, no obstante, que el alumno utilice el estilo de presentación que se detallará más
adelante, ya que ello contribuirá a homogeneizar la presentación de los programas de los diferentes
programadores, facilitando la lectura de los programas de unos por otros.
1250$6 '( (67,/2 $ 7(1(5 (1 &8(17$ (1 (/ ',6(f2 '(/
352*5$0$
En este apartado se repasarán aquellos principios básicos que son generalmente considerados como
buenas pautas a seguir de cara a conseguir programas con unos requisitos mínimos de calidad. Además, se
exponen una serie de recomendaciones que, sin ser principios básicos, contribuyen a mejorar el diseño de los
programas.
No se pretende explicar ni justificar la conveniencia de la aplicación de tales principios, sino tan
solo hacer hincapié en la necesidad de que el alumno los tenga en cuenta a la hora de elaborar sus programas,
y no piense que se trata de cuestiones teóricas que después no necesita aplicar a los programas que desarrolla.
Para ello, se han redactado como un documento recopilatorio que pueda ser consultado de forma rápida por
el alumno hasta que la forma de razonar y programar que llevan implícitos resulte natural en el alumno. Si el
alumno no es capaz de discutir y valorar la conveniencia de tener en cuenta alguno de estos principios, se
recomienda que repase los aspectos básicos de la teoría de la programación que atañen a dicho punto.
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 2
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
1RUPDVEiVLFDV
Se deben aplicar siempre porque forman parte de la teoría básica
• $SOLTXHODPHWRGRORJtDGHGLVHxRGHVFHQGHQWH
• 3LHQVHHQODVHVWUXFWXUDVGHGDWRVDXWLOL]DUDQWHVGHFRQVLGHUDUODVHVWUXFWXUDVGHFRQWURO
• 6HDFXLGDGRVRDOHOHJLUODUHSUHVHQWDFLyQDGHFXDGDSDUDVXVGDWRV. Ello puede afectar en gran medida a
su programa.
• 0RGXODULFH8VHVXESURJUDPDV
• (YLWHP~WLSOHVVDOLGDVGHORVVXESURJUDPDV. Cada subprograma debe tener un único punto de entrada y
un único punto de salida.
• +X\DGHORVHIHFWRVODWHUDOHV. Haga visible el acoplamiento entre los subprogramas.
• 8Q VXESURJUDPD GHEH VHU HO UHVXOWDGR GH OD DEVWUDFFLyQ GH XQD ~QLFD RSHUDFLyQ. Si se combinan
diversas funcionalidades en el mismo subprograma éste será dificilmente reutilizable.
• 1RXWLOLFHH[FHVLYRVQLYHOHVGHDQLGDPLHQWRHQVXVHVWUXFWXUDVGHFRQWURO
• 6LSURFHGHXVHSURFHGLPLHQWRVUHFXUVLYRVSDUDWUDWDUODVHVWUXFWXUDVGHGDWRVGHILQLGDVUHFXUVLYDPHQWH.
• /LEHUHORVUHFXUVRVHQHOPLVPRVXESURJUDPDTXHORVDGTXLHUH. (Abrir - Usar - Cerrar).
• (YLWHXVDUEXFOHV/223
5HFRPHQGDFLRQHVDWHQHUHQFXHQWD Se deben intentar aplicar
• (VFULED SULPHUR HQ XQ SVHXGROHQJXDMH IiFLO GH FRPSUHQGHU \ OXHJR WUDGX]FD DO OHQJXDMH TXH HVWp
XWLOL]DQGR
• (VFULEDGHIRUPDFODUDQRLQWHQWHVHUGHPDVLDGRLQJHQLRVR. Es más importante obtener un código legible
y con baja probabilidad de errores que hacer alarde de virtuosismo.
• 1RVDFULILTXHFODULGDGSRUHILFLHQFLD
• 1RSDUFKHHHOFyGLJRVLHVQHFHVDULRUHHVFUtEDOR
• 1RVHGHWHQJDHQVXSULPHUERUUDGRUGHOSURJUDPD
• $VHJ~UHVHGHTXHGDYDORUHVLQLFLDOHVDWRGDVODVYDULDEOHVDQWHVGHVXXVR
• (YLWHHOXVRDEXVLYRGHYDULDEOHVWHPSRUDOHV
• 'HMHTXHODPiTXLQDKDJDHOWUDEDMRVXFLR
Por ejemplo, si se desea declarar constantes que representen el número de filas, columnas y elementos de
una tabla, es preferible:
NumFilas = 13;
NumCol
= 7;
NumElem = NumFilas * NumCol;
antes que:
NumFilas = 13;
NumCol
= 7;
NumElem = 91;
porque la primera versión es más clara y menos propensa a errores, y además, no es menos eficiente (los
compiladores hacen dichos cálculos en tiempo de compilación).
• 8WLOLFH,)7+(1(/6((1'SDUDHQIDWL]DUTXHVyORXQDGHGRVDFFLRQHVGHEHVHUHMHFXWDGDEllo suele
ser más claro para expresar la exclusión entre dos alternativas que si en su lugar se utilizan dos
instrucciones IF-THEN-END consecutivas.
• (YLWH ODV H[SUHVLRQHV FRPSOHMDV HQ VXV SURJUDPDV 6L XQD H[SUHVLyQ OyJLFD HV GLItFLO GH FRPSUHQGHU
TXL]iVVHDFRQYHQLHQWHDEVWUDHUODGHILQLHQGRXQRRYDULRVVXESURJUDPDV
• 8WLOLFHDUUD\VSDUDHYLWDUUHSHWLFLRQHV
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 3
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
Por ejemplo, compare:
(* ‘Valor’ contiene el valor en pesetas de diversas monedas *)
(* ‘Nombre’ contiene el nombre de cada moneda *)
Ind := NumMonedas;
WHILE (Ind > 0) AND (Importe > 0) DO
Unidades := Importe DIV Valor[Ind];
IF Unidades > 0 THEN
WrCard(Num,0); WrStr(Nombre[Ind]);
END;
Importe :=Importe MOD Valor[Ind];
Ind := Ind - 1
END
Respecto a un ejemplo que use multiples IF para comparar de qué moneda se trata a la hora de escribir y
para saber por qué cantidad dividir.
• (OFXHUSRGHXQEXFOHGHEHVHUXQSURFHVRUHSHWLWLYRPor lo tanto, si alguna acción no repetitiva (que
sólo se ejecuta una vez inmediatamente antes de salir del bucle) aparece dentro de un bucle, plantéese la
posibilidad de rediseñar el código del bucle para que la acción repetitiva no forme parte del cuerpo del
bucle.
• (YLWHUHSHWLUODVPLVPDVDFFLRQHVHQDPEDVDOWHUQDWLYDVGHXQDLQVWUXFFLyQ,)7+(1(/6((1'En la
mayoría de los casos el programa quedaría más claro si se saca factor común de dicha acción y se sitúa
antes o después de la instrucción de selección (además, !ese código se ejecutaría siempre!).
• 1RXWLOLFHHVWUXFWXUDVGHWLSRIF (Cond = TRUE) THEN
• /RVVXESURJUDPDVQRGHEHQVHUH[FHVLYDPHQWHJUDQGHV6LORVRQPRGXODULFHDXQPiV
• &XDQGRPXHVWUHFXDOTXLHUPHQVDMHSRUSDQWDOODHYLWHKDFHUUHIHUHQFLDDOFRQWHQLGRGHOSURJUDPD. Un
mensaje como ERROR 103 EN PROCEDIMIENTO PX11 TRAS ACUMULAR AUX no ayuda nada al
usuario de la aplicación.
• &XDQGRGHVDUUROOHOLEUHUtDVGHFyGLJROLPLWHDOPtQLPRSRVLEOHORVPHQVDMHVSRUSDQWDOOD. Úselos sólo
para informar sobre algún error durante la ejecución. Es el usuario de la biblioteca el que debe dar los
mensajes pertinentes según la aplicación que desarrolle. Evidentemente esto no significa que no pueda
escribirse nada en pantalla desde los procedimientos de una biblioteca pues, por ejemplo, sería entonces
imposible diseñar un módulo para manejar un TAD_MENU que automatice el manejo de menúes. Sólo nos
referimos a operaciones de entrada/salida no directamente relacionadas con el objetivo de la biblioteca.
Por ejemplo, si desarrollamos el TAD COMPLEJO, al codificar la función Leer_Cmp() no incluya
WrStr(“Teclee el número complejo (R,I):”).
1250$6'((67,/2'(35(6(17$&,Ï1
En este apartado se van a comentar algunas sugerencias referentes a las normas de estilo de
presentación que se pueden aplicar a los programas escritos en Modula-2, aunque las recomendaciones son
extensibles a cualquier lenguaje. Se pretende que el lector sea capaz de establecer por sí mismo unas normas
adecuadas que definan su propio estilo de programación y que las aplique a todos los programas que
codifique.
Denominaremos HVWLORGHSUHVHQWDFLyQGHXQSURJUDPD a un conjunto de convenciones y reglas
que se aplican a los programas con el objetivo de facilitar la lectura, depuración y comprensión de los
mismos.
Un estilo de programación debe ser, como mínimo, FRQVLVWHQWH y VLPSOH. Consistente significa, por
ejemplo, que si todos los identificadores de constantes se escriben en mayúsculas, no puede existir una
constante cuyo identificador sea dimension. Simple quiere decir, por ejemplo, que (aunque es
conveniente que los identificadores den idea de aquello a que describen), no tiene utilidad una norma que
establezca que los identificadores de las variables tengan que indicar exactamente el uso de las mismas en el
programa, como VariableQueSeUsaComoVariableDeControlDeBucles.
No existe un criterio unificado sobre las normas que definen un buen estilo de programación y, en la
mayoría de los casos, las normas suelen ser bastante flexibles. En general, se suelen dar recomendaciones
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 4
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
sobre los siguientes aspectos: programa, identificadores, comentarios, ruptura de sentencias y expresiones, y
los criterios que utilizar para resaltar adecuadamente las declaraciones y estructuras de control anidadas.
El hecho de que cada programador tenga unas reglas de estilo adecuadas no sólo permite facilitar la
lectura y compresión de los programas por él mismo o por otros programadores, sino que, durante la fase de
desarrollo, los errores son más fáciles de detectar. Por tanto, las normas de estilo se deben aplicar mientras
se codifican los programas. No tiene sentido escribir en primer lugar las líneas de código para después
aplicar las normas de estilo.
,GHQWLILFDGRUHV
• Deben ser representativos de su contenido, aunque se pueden establecer convenciones en casos concretos,
como el caso de las variables que se usan para el control en bucles.
&2167
9$5
DIMENSION = 10;
(* Cte. que indica el tamaño de un array *)
opcion : &+$5;
(* Variable de control de un menú
suma
: &$5',1$/;(* Suma de los elementos de una array
*)
*)
• No extender una declaración de múltiples variables más allá de una línea. Por ejemplo, es preferible
9$5
suma, saldo : ,17(*(5 ó
9$5
suma : ,17(*(5;
saldo : ,17(*(5
En lugar de:
9$5
suma,
saldo : ,17(*(5
• No utilizar la misma variable local para diferentes tipos de operaciones en el mismo subprograma. Por
ejemplo, no es adecuado definir una variable “contador”, que despues tenga diferentes usos dentro del
mismo procedimiento. Utilizar diferentes variables locales para diferentes tipos de operaciones aumenta
la claridad del código escrito, así mismo en algunos compiladores permite generar un código ejecutable
optimizado.
• Si el identificador combina varias palabras (o abreviaturas de palabras), cada una de ellas puede
comenzar con mayúscula, o bien, se pueden separar por el carácter '_' (o ambas cosas).
AcumuladorResultados
suma_total
Inc_Saldo
: ,17(*(5;
: 5($/;
: %22/($1;
• Como nombre de módulo elija el término más general y preciso que defina su contenido. Por ejemplo, si
un módulo contiene la definición de un tipo pila de caracteres y los procedimientos y funciones que
operan sobre ese tipo, el nombre del módulo podría ser PILA o PILA_CH, pero si únicamente contiene
la definición del tipo abstracto de datos pila de caracteres debería de llamarse TIPO_PILA o algo similar
(TAD_PILA, por ejemplo).
• El nombre de un tipo abstracto de datos no debe informar acerca de cómo está implementado. Por
ejemplo, no llame a un tipo Ptr_Nodo sino Lista cuando desee definir una lista de elementos
enlazados.
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 5
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
&RPHQWDULRV
Los comentarios deben ayudar a mejorar la legibilidad del código del programa, por tanto, no basta con que
un programa tenga comentarios, sino que éstos deben ser coherentes. Por tanto, tenga en cuenta que:
• no debe escribir comentarios que prácticamente sean una copia del código de programa, sin aportar
nada.
• no debe comentar en exceso, hasta tal punto que resulte difícil la localización y lectura del código de
programa.
• no debe intentar comentar un mal programa para hacerlo más claro, en su lugar, probablemente sea
más conveniente reescribirlo.
Asegúrese que los comentarios son realmente correctos. Los comentarios que no se corresponden con lo que
realmente hace un determinado trozo de código dificulta en gran medida la localización de errores.
Si el programa está destinado a usuarios españoles los comentarios y mensajes por pantalla deben estar
redactados en correcto español.
Se pueden distinguir varios tipos de comentarios dentro de un programa:
• De cabecera de módulos: Deben escribirse al comienzo de cada módulo, delimitados por líneas en blanco
o rellenas de un determinado carácter (asteriscos, guiones, etc.), incluyendo la identificación del módulo,
autor, fecha, versión y una breve descripción del contenido del módulo. Las modificaciones deben
enumerarse indicando fecha, autor y modificación realizada.
(*--------------------------------------------------------------*)
(*
Módulo CALCULADORA
*)
(*
Autor: José López Gutiérrez
*)
(*
Fecha: 17-10-99
Versión: 1.0
*)
(*--------------------------------------------------------------*)
(*
Programa que implementa una calculadora simple
*)
(*--------------------------------------------------------------*)
(*
*)
• De cabecera de procedimientos: Se escriben justo antes o al principio de los procedimientos y en ellos se
comenta brevemente toda aquella información que sea importante como, por ejemplo, función que
realiza, algoritmo empleado, precondiciones, postcondiciones, argumentos, etc.
(****************************************************************)
(* PROCEDURE
:ordenar_vector
*)
(* OBJETIVO
:ordena un array de enteros en orden ascendente *)
(* ALGORITMO
:se emplea el algoritmo de ordenación quicksort *)
(* PRECONDICIÓN :el parámetro es un vector de enteros que debe *)
(*
estar lleno
*)
(* POSTCONDICIÓN:el parámetro vector contiene los números
*)
(*
ordenados ascendentemente
*)
(****************************************************************)
352&('85( ordenar_vector(9$5 vector: VECTOR);
• Para explicar el funcionamiento de un subprograma es conveniente apoyarse en el nombre de las variables
parámetro que dicho subprograma recibe. Así, por ejemplo, diríamos
(*Esta función busca el nodo NUM_NODO en el árbol binario BARBOL*)
352&('85( buscar_nodo(num_nodo:tnodo; barbol:tarbol);
en lugar de
(*Esta función busca un nodo en un árbol binario*)
352&('85( buscar_nodo(num_nodo:tnodo; barbol:tarbol);
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 6
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
• De definición: Deben incluirse en las declaraciones de tipos, variables y parámetros de procedimientos
cuando los identificadores de los mismos no sean lo suficientemente aclaratorios.
9$5
contador: ,17(*(5;(*Cuenta los caracteres leídos del teclado*)
• De ruptura de párrafos: Cuando dentro del código aparecen párrafos excesivamente largos, se suelen
utilizar comentarios para romperlos en fragmentos más compresibles.
• De control: Es aconsejable comentar los END de estructuras de control anidadas indicando qué estructura
cierran.
(* Posiblemente aquí debiera aparecer un comentario *)
:+,/( condición '2
)25 i := 1 72 N '2
,) (NumElem > 0) 7+(1
...
(1'; (* IF quedan elementos*)
(1'; (* FOR i*)
(1'; (* WHILE condición*)
)RUPDWRGH6HQWHQFLDV\([SUHVLRQHV
En esta sección se presentan algunos consejos relacionados con la disposición en el programa de las
sentencias y las expresiones.
• No escribir más de una sentencia por línea, con la excepción de sentencias muy cortas y relacionadas
entre sí, como, por ejemplo, la asignación de valores iniciales a las variables. De cualquier forma, la
presencia de más de una sentencia por línea dificulta la depuración de los programas cuando se usan
herramientas de depuración de errores.
i := 0; j := 1; k := 0;
• Procurar no escribir líneas de código que superen el ancho de la pantalla del editor.
• Si una sentencia o declaración no cabe entera en una línea, romperla en algún punto lógico.
352&('85( ConcatenarCadena(cadena1: CADENA;
cadena2: CADENA;
9$5 cadena3: CADENA);
• Se puede mejorar la legibilidad de las expresiones rodeando con un espacio en blanco los símbolos de
operación y asignación.
,) ((i < 5) $1' (FIN)) 7+(1
j := 5 ;
(1' (* IF *)
• Utilizar paréntesis en las expresiones, aunque no sean necesarios, si ello ayuda a mejorar su comprensión.
(A + B) > (7 * X / 2)
• Si una expresión ocupa más de una línea, rompa la línea de forma coherente. Se podrá hacer antes ó
después de un operador, pero siempre se deberá seguir el mismo criterio. Además, si es posible, procure
romper la línea en un operador de baja precedencia. Por ejemplo, si se mantiene el criterio de romper la
línea después de un operador, tendríamos:
,) (((valor > 25) $1' (127 FIN))
25
((suma = 0)
$1' (CONTINUAR)))
• Añadir espacios a la izquierda de las líneas de continuación de sentencias o expresiones, de modo que las
partes relacionadas queden alineadas verticalmente (vea el ejemplo anterior).
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 7
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
6DQJUDGR
Se usa para hacer patente la profundidad de los anidamientos en declaraciones y estructuras de
control. El cuerpo de programa principal y de los distintos subprogramas ha de llevar un sangrado adecuado
con respecto al comienzo y final del mismo (véase el ejemplo al final).
Cada nivel debe empezar varios espacios a la derecha del anterior. Hay que tener en cuenta que si
se usan pocos espacios (uno o dos), el sangrado tiene poca utilidad porque es difícil de distinguir los
diferentes niveles. Por el contrario, si se usan muchos espacios, en cuanto que existan más de tres o cuatro
niveles las líneas se vuelven muy cortas y hay que romperlas con frecuencia, de forma que los beneficios del
sangrado se pierden.
(* Ejemplo de sangrado a dos espacios. Poco útil *)
i := 1;
:+,/( (i < 10)'2
,) (persona[i].edad >= 18) 7+(1
WrStr("Mayor de edad");
(/6(
WrStr("Menor de edad");
(1'; (* IF comprobación de edad *)
(1'; (* WHILE i < 10 *)
(* Ejemplo de sangrado a diez espacios. Exagerado *)
i := 1;
:+,/( (i < 10)'2
,) (persona[i].edad >= 18) 7+(1
WrStr("Mayor de edad");
(/6(
WrStr("Menor de edad");
(1'; (* IF comprobación de edad *)
(1'; (* WHILE i < 10 *)
(* Ejemplo de sangrado a cuatro espacios. Útil *)
i := 1;
:+,/( (i < 10)'2
,) (persona[i].edad >= 18) 7+(1
WrStr("Mayor de edad");
(/6(
WrStr("Menor de edad");
(1'; (* IF comprobación de edad *)
(1'; (* WHILE i < 10 *)
• 'HFODUDFLRQHV
− Para constantes, variables y tipos, empezar en la línea siguiente a la de su correspondiente palabra
reservada, dejando algunos espacios en blanco.
&2167
PI =
N =
7<3(
EDAD
9$5
edad
i, j
3.1416;
16;
= &$5',1$/;
:EDAD;
(* Almacena la edad de un individuo *)
:&$5',1$/; (* Variables de control de bucles
*)
− Los comentarios de declaración conviene que estén alineados verticalmente.
− Alinear, siempre que sea posible, los tipos de las variables.
persona = 5(&25'
nombre
edad
sexo
(1';
: CADENA;
: &$5',1$/;
: SEXO;
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 8
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
• (VWUXFWXUDVGH&RQWURO
− Sentencia ,)
,) condición 7+(1
sentencias
(/6,) condición 7+(1
sentencias
...
(/6(
sentencias
(1' (* IF condición*)
− Sentencia &$6(
&$6( selector 2)
caso-1
| ...
| caso-n
(1' (* CASE selector *)
− Sentencia :+,/(
:+,/( condición '2
sentencias
(1' (* WHILE condición*)
− Sentencia 5(3($7
5(3($7 (* Hasta condición *)
sentencias
817,/ condición
− Sentencia )25
)25 indice := valor_inicial 72 valor_final %< incremento '2
sentencias
(1' (* FOR *)
− Sentencia :,7+
:,7+ registro '2
sentencias
(1' (* WITH *)
'LVWULEXFLyQGH6XESURJUDPDV
Distribuya adecuadamente los procedimientos dentro de un programa. Si el lenguaje aporta la posibilidad de
anidar subprogramas, dicha característica debe ser utilizada para anidar los subprogramas en aquellos para
los que han sido definidos, contribuyendo de esta forma a permitir que se pueda interpretar el código del
programa siguiendo el enfoque descendente empleado para su planeamiento.
3URJUDPD(MHPSOR
A continuación se muestra, como ejemplo que ilustra algunas de las recomendaciones de estilo comentadas,
un programa que calcula el Q-ésimo término de la sucesión de Fibonacci.
x =1

y = f ( x) x = 2
x > 2

1
1
f ( x − 1) + f ( x − 2 )
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 9
Dpto. Lenguajes y Ciencias de la Computación ( Universidad de Málaga )
(*----------------------------------------------------------------------------*)
(*
MODULO FIBONACCI
*)
(*
AUTOR: Juan López
*)
(*
FECHA: 30-10-99
*)
(*
VERSION: 1.0
*)
(*----------------------------------------------------------------------------*)
(*
Programa que calcula el n-ésimo elemento de la sucesión de
*)
(*
Fibonacci (1 1 2 3 5 8 ...)
*)
(*----------------------------------------------------------------------------*)
(*
*)
02'8/( fibonacci;
)520 IO ,03257 WrStr, WrCard, WrLn, RdCard, OK;
(*------------------------------------------------------------------------*)
(* PROCEDURE:
LeerPos
*)
(* OBJETIVO:
Devuelve un número que representa una posición en la
*)
(*
serie de Fibonacci.
*)
(* PRECONDICIÓN: Ninguna
*)
(* POSTCONDICIÓN: El número devuelto es mayor que cero.
*)
(*------------------------------------------------------------------------*)
352&('85( LeerPos():&$5',1$/;
(*--------------------------------------------------------------------*)
(* PROCEDURE: PosValida
*)
(* OBJETIVO: Devuelve TRUE si el parámetro pos contiene una posición *)
(*
válida para un número de Fibonacci y FALSE en otro caso *)
(* PRECOND:
Ninguna
*)
(*--------------------------------------------------------------------*)
352&('85( PosValida(pos:&$5',1$/):%22/($1;
%(*,1
5(7851 (pos > 0);
(1' PosValida;
9$5
pos : &$5',1$/;
(* Para recibir la posición leída de teclado *)
%(*,1 (* De LeerPos() *)
5(3(7,5
pos := RdCard();
817,/(OK$1'PosValida(pos));
5(7851 pos;
(1' LeerPos;
(*------------------------------------------------------------------------*)
(* PROCEDURE:
fibo
*)
(* MISIÓN:
Calcula el elemento de la serie de Fibonacci que ocupa la*)
(*
posición indicada por el parámetro “n”
*)
(* PRECONDICIÓN: El parámetro “n” debe contener un número mayor que cero *)
(*------------------------------------------------------------------------*)
352&('85( fibo(n:&$5',1$/):&$5',1$/;
9$5
%(*,1
result : &$5',1$/;
(* Valor de Fibonacci calculado hasta el momento *)
pos
: &$5',1$/;
(* Posicion del valor de Fibonacci calculado en result*)
actual, anterior : &$5',1$/;
(* Los dos ultimos valores calculados *)
result
:= 1;
anterior := 1;
actual
:= 1;
)25 pos := 3 72 n '2
result
:= anterior + actual;
anterior := actual;
actual
:= result;
(1';
5(7851 result;
(1' fibo;
9$5
pos :&$5',1$/;
(* Posición del número a calcular *)
%(*,1(* Cuerpo principal del módulo *)
(* Petición de datos. No se valida el dato introducido. *)
WrStr("Introduzca el elemento de la sucesión de Fibonacci a calcular: " );
pos := LeerPos();
WrStr("El ");
WrCard(pos, 0);
WrStr("-ésimo término de la sucesión de Fibonacci es: ");
WrCard(fibo(pos), 0);
(1' fibonacci. (* MODULE *)
_______________________________________________________________________________________
CRITERIOS GENERALES SOBRE EL ESTILO EN PROGRAMACIÓN
Pág 10